2019-06-13 06:30:51 +00:00
|
|
|
# -*- coding:utf-8 -*-
|
|
|
|
#
|
2008-10-21 14:00:00 +00:00
|
|
|
# Copyright (C) 2008 The Android Open Source Project
|
|
|
|
#
|
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
# you may not use this file except in compliance with the License.
|
|
|
|
# You may obtain a copy of the License at
|
|
|
|
#
|
|
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
#
|
|
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
# See the License for the specific language governing permissions and
|
|
|
|
# limitations under the License.
|
|
|
|
|
2012-11-02 05:59:27 +00:00
|
|
|
from __future__ import print_function
|
2008-11-03 17:59:36 +00:00
|
|
|
import errno
|
2008-10-21 14:00:00 +00:00
|
|
|
import filecmp
|
2015-06-03 15:05:17 +00:00
|
|
|
import glob
|
2019-06-18 21:23:39 +00:00
|
|
|
import json
|
2008-10-21 14:00:00 +00:00
|
|
|
import os
|
2011-10-03 15:30:24 +00:00
|
|
|
import random
|
2008-10-21 14:00:00 +00:00
|
|
|
import re
|
|
|
|
import shutil
|
|
|
|
import stat
|
2012-08-02 21:57:37 +00:00
|
|
|
import subprocess
|
2008-10-21 14:00:00 +00:00
|
|
|
import sys
|
2013-10-16 09:02:35 +00:00
|
|
|
import tarfile
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
import tempfile
|
2011-10-03 15:30:24 +00:00
|
|
|
import time
|
2015-01-02 19:12:54 +00:00
|
|
|
import traceback
|
2011-10-11 21:05:21 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
from color import Coloring
|
2012-10-31 19:27:27 +00:00
|
|
|
from git_command import GitCommand, git_require
|
2016-02-10 17:44:30 +00:00
|
|
|
from git_config import GitConfig, IsId, GetSchemeFromUrl, GetUrlCookieFile, \
|
|
|
|
ID_RE
|
2014-11-12 18:27:45 +00:00
|
|
|
from error import GitError, HookError, UploadError, DownloadError
|
2009-03-02 20:56:08 +00:00
|
|
|
from error import ManifestInvalidRevisionError
|
2012-11-16 01:33:11 +00:00
|
|
|
from error import NoManifestException
|
2016-11-01 18:24:03 +00:00
|
|
|
import platform_utils
|
2019-08-26 19:22:36 +00:00
|
|
|
import progress
|
2019-08-27 04:26:15 +00:00
|
|
|
from repo_trace import IsTrace, Trace
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-04-18 01:49:50 +00:00
|
|
|
from git_refs import GitRefs, HEAD, R_HEADS, R_TAGS, R_PUB, R_M
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2013-05-17 01:49:33 +00:00
|
|
|
from pyversion import is_python3
|
2016-08-16 01:23:44 +00:00
|
|
|
if is_python3():
|
|
|
|
import urllib.parse
|
|
|
|
else:
|
|
|
|
import imp
|
|
|
|
import urlparse
|
|
|
|
urllib = imp.new_module('urllib')
|
|
|
|
urllib.parse = urlparse
|
2013-03-01 13:44:38 +00:00
|
|
|
input = raw_input
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2009-04-18 21:45:51 +00:00
|
|
|
def _lwrite(path, content):
|
|
|
|
lock = '%s.lock' % path
|
|
|
|
|
2019-11-11 10:40:22 +00:00
|
|
|
with open(lock, 'w') as fd:
|
2009-04-18 21:45:51 +00:00
|
|
|
fd.write(content)
|
|
|
|
|
|
|
|
try:
|
2016-11-01 18:34:55 +00:00
|
|
|
platform_utils.rename(lock, path)
|
2009-04-18 21:45:51 +00:00
|
|
|
except OSError:
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(lock)
|
2009-04-18 21:45:51 +00:00
|
|
|
raise
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2009-04-16 15:25:57 +00:00
|
|
|
def _error(fmt, *args):
|
|
|
|
msg = fmt % args
|
2012-11-02 05:59:27 +00:00
|
|
|
print('error: %s' % msg, file=sys.stderr)
|
2009-04-16 15:25:57 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2015-08-24 05:39:14 +00:00
|
|
|
def _warn(fmt, *args):
|
|
|
|
msg = fmt % args
|
|
|
|
print('warn: %s' % msg, file=sys.stderr)
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def not_rev(r):
|
|
|
|
return '^' + r
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2009-01-06 00:18:58 +00:00
|
|
|
def sq(r):
|
|
|
|
return "'" + r.replace("'", "'\''") + "'"
|
2008-11-03 18:32:09 +00:00
|
|
|
|
2015-03-17 18:29:58 +00:00
|
|
|
_project_hook_list = None
|
2016-02-10 17:44:30 +00:00
|
|
|
|
|
|
|
|
2015-03-17 18:29:58 +00:00
|
|
|
def _ProjectHooks():
|
|
|
|
"""List the hooks present in the 'hooks' directory.
|
|
|
|
|
|
|
|
These hooks are project hooks and are copied to the '.git/hooks' directory
|
|
|
|
of all subprojects.
|
|
|
|
|
|
|
|
This function caches the list of hooks (based on the contents of the
|
|
|
|
'repo/hooks' directory) on the first call.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
A list of absolute paths to all of the files in the hooks directory.
|
|
|
|
"""
|
|
|
|
global _project_hook_list
|
|
|
|
if _project_hook_list is None:
|
2016-11-01 21:37:13 +00:00
|
|
|
d = platform_utils.realpath(os.path.abspath(os.path.dirname(__file__)))
|
2015-03-17 18:29:58 +00:00
|
|
|
d = os.path.join(d, 'hooks')
|
2018-09-27 17:46:58 +00:00
|
|
|
_project_hook_list = [os.path.join(d, x) for x in platform_utils.listdir(d)]
|
2015-03-17 18:29:58 +00:00
|
|
|
return _project_hook_list
|
|
|
|
|
|
|
|
|
2008-10-23 18:58:52 +00:00
|
|
|
class DownloadedChange(object):
|
|
|
|
_commit_cache = None
|
|
|
|
|
|
|
|
def __init__(self, project, base, change_id, ps_id, commit):
|
|
|
|
self.project = project
|
|
|
|
self.base = base
|
|
|
|
self.change_id = change_id
|
|
|
|
self.ps_id = ps_id
|
|
|
|
self.commit = commit
|
|
|
|
|
|
|
|
@property
|
|
|
|
def commits(self):
|
|
|
|
if self._commit_cache is None:
|
2016-02-10 17:44:30 +00:00
|
|
|
self._commit_cache = self.project.bare_git.rev_list('--abbrev=8',
|
|
|
|
'--abbrev-commit',
|
|
|
|
'--pretty=oneline',
|
|
|
|
'--reverse',
|
|
|
|
'--date-order',
|
|
|
|
not_rev(self.base),
|
|
|
|
self.commit,
|
|
|
|
'--')
|
2008-10-23 18:58:52 +00:00
|
|
|
return self._commit_cache
|
|
|
|
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
class ReviewableBranch(object):
|
|
|
|
_commit_cache = None
|
2019-09-11 22:43:17 +00:00
|
|
|
_base_exists = None
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
def __init__(self, project, branch, base):
|
|
|
|
self.project = project
|
|
|
|
self.branch = branch
|
|
|
|
self.base = base
|
|
|
|
|
|
|
|
@property
|
|
|
|
def name(self):
|
|
|
|
return self.branch.name
|
|
|
|
|
|
|
|
@property
|
|
|
|
def commits(self):
|
|
|
|
if self._commit_cache is None:
|
2019-09-11 22:43:17 +00:00
|
|
|
args = ('--abbrev=8', '--abbrev-commit', '--pretty=oneline', '--reverse',
|
|
|
|
'--date-order', not_rev(self.base), R_HEADS + self.name, '--')
|
|
|
|
try:
|
|
|
|
self._commit_cache = self.project.bare_git.rev_list(*args)
|
|
|
|
except GitError:
|
|
|
|
# We weren't able to probe the commits for this branch. Was it tracking
|
|
|
|
# a branch that no longer exists? If so, return no commits. Otherwise,
|
|
|
|
# rethrow the error as we don't know what's going on.
|
|
|
|
if self.base_exists:
|
|
|
|
raise
|
|
|
|
|
|
|
|
self._commit_cache = []
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
return self._commit_cache
|
|
|
|
|
2008-11-12 01:12:43 +00:00
|
|
|
@property
|
|
|
|
def unabbrev_commits(self):
|
|
|
|
r = dict()
|
2016-02-10 17:44:30 +00:00
|
|
|
for commit in self.project.bare_git.rev_list(not_rev(self.base),
|
|
|
|
R_HEADS + self.name,
|
|
|
|
'--'):
|
2008-11-12 01:12:43 +00:00
|
|
|
r[commit[0:8]] = commit
|
|
|
|
return r
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
@property
|
|
|
|
def date(self):
|
2016-02-10 17:44:30 +00:00
|
|
|
return self.project.bare_git.log('--pretty=format:%cd',
|
|
|
|
'-n', '1',
|
|
|
|
R_HEADS + self.name,
|
|
|
|
'--')
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2019-09-11 22:43:17 +00:00
|
|
|
@property
|
|
|
|
def base_exists(self):
|
|
|
|
"""Whether the branch we're tracking exists.
|
|
|
|
|
|
|
|
Normally it should, but sometimes branches we track can get deleted.
|
|
|
|
"""
|
|
|
|
if self._base_exists is None:
|
|
|
|
try:
|
|
|
|
self.project.bare_git.rev_parse('--verify', not_rev(self.base))
|
|
|
|
# If we're still here, the base branch exists.
|
|
|
|
self._base_exists = True
|
|
|
|
except GitError:
|
|
|
|
# If we failed to verify, the base branch doesn't exist.
|
|
|
|
self._base_exists = False
|
|
|
|
|
|
|
|
return self._base_exists
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
def UploadForReview(self, people,
|
|
|
|
auto_topic=False,
|
2017-08-08 18:34:53 +00:00
|
|
|
draft=False,
|
2017-08-02 14:55:03 +00:00
|
|
|
private=False,
|
2018-10-31 20:48:01 +00:00
|
|
|
notify=None,
|
2017-08-02 14:55:03 +00:00
|
|
|
wip=False,
|
2017-08-08 08:18:11 +00:00
|
|
|
dest_branch=None,
|
2017-11-13 18:48:34 +00:00
|
|
|
validate_certs=True,
|
|
|
|
push_options=None):
|
2008-11-12 01:12:43 +00:00
|
|
|
self.project.UploadForReview(self.name,
|
2010-07-15 23:52:42 +00:00
|
|
|
people,
|
2012-07-28 22:37:04 +00:00
|
|
|
auto_topic=auto_topic,
|
2017-08-08 18:34:53 +00:00
|
|
|
draft=draft,
|
2017-08-02 14:55:03 +00:00
|
|
|
private=private,
|
2018-10-31 20:48:01 +00:00
|
|
|
notify=notify,
|
2017-08-02 14:55:03 +00:00
|
|
|
wip=wip,
|
2017-08-08 08:18:11 +00:00
|
|
|
dest_branch=dest_branch,
|
2017-11-13 18:48:34 +00:00
|
|
|
validate_certs=validate_certs,
|
|
|
|
push_options=push_options)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-05-04 19:45:11 +00:00
|
|
|
def GetPublishedRefs(self):
|
|
|
|
refs = {}
|
|
|
|
output = self.project.bare_git.ls_remote(
|
2016-02-10 17:44:30 +00:00
|
|
|
self.branch.remote.SshReviewUrl(self.project.UserEmail),
|
|
|
|
'refs/changes/*')
|
2009-05-04 19:45:11 +00:00
|
|
|
for line in output.split('\n'):
|
|
|
|
try:
|
|
|
|
(sha, ref) = line.split()
|
|
|
|
refs[sha] = ref
|
|
|
|
except ValueError:
|
|
|
|
pass
|
|
|
|
|
|
|
|
return refs
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
class StatusColoring(Coloring):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def __init__(self, config):
|
|
|
|
Coloring.__init__(self, config, 'status')
|
2014-07-16 11:56:40 +00:00
|
|
|
self.project = self.printer('header', attr='bold')
|
|
|
|
self.branch = self.printer('header', attr='bold')
|
|
|
|
self.nobranch = self.printer('nobranch', fg='red')
|
|
|
|
self.important = self.printer('important', fg='red')
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2014-07-16 11:56:40 +00:00
|
|
|
self.added = self.printer('added', fg='green')
|
|
|
|
self.changed = self.printer('changed', fg='red')
|
|
|
|
self.untracked = self.printer('untracked', fg='red')
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
|
|
|
|
class DiffColoring(Coloring):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def __init__(self, config):
|
|
|
|
Coloring.__init__(self, config, 'diff')
|
2014-07-16 11:56:40 +00:00
|
|
|
self.project = self.printer('header', attr='bold')
|
2019-10-01 03:59:27 +00:00
|
|
|
self.fail = self.printer('fail', fg='red')
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2014-07-16 11:56:40 +00:00
|
|
|
class _Annotation(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2012-04-12 20:04:13 +00:00
|
|
|
def __init__(self, name, value, keep):
|
|
|
|
self.name = name
|
|
|
|
self.value = value
|
|
|
|
self.keep = keep
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2014-07-16 11:56:40 +00:00
|
|
|
class _CopyFile(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2009-03-05 18:32:38 +00:00
|
|
|
def __init__(self, src, dest, abssrc, absdest):
|
2008-10-21 14:00:00 +00:00
|
|
|
self.src = src
|
|
|
|
self.dest = dest
|
2009-03-05 18:32:38 +00:00
|
|
|
self.abs_src = abssrc
|
|
|
|
self.abs_dest = absdest
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
def _Copy(self):
|
2009-03-05 18:32:38 +00:00
|
|
|
src = self.abs_src
|
|
|
|
dest = self.abs_dest
|
2008-10-21 14:00:00 +00:00
|
|
|
# copy file if it does not exist or is out of date
|
|
|
|
if not os.path.exists(dest) or not filecmp.cmp(src, dest):
|
|
|
|
try:
|
|
|
|
# remove existing file first, since it might be read-only
|
|
|
|
if os.path.exists(dest):
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(dest)
|
2009-07-11 13:43:47 +00:00
|
|
|
else:
|
2012-09-29 22:37:55 +00:00
|
|
|
dest_dir = os.path.dirname(dest)
|
2018-09-27 17:46:58 +00:00
|
|
|
if not platform_utils.isdir(dest_dir):
|
2012-09-29 22:37:55 +00:00
|
|
|
os.makedirs(dest_dir)
|
2008-10-21 14:00:00 +00:00
|
|
|
shutil.copy(src, dest)
|
|
|
|
# make the file read-only
|
|
|
|
mode = os.stat(dest)[stat.ST_MODE]
|
|
|
|
mode = mode & ~(stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH)
|
|
|
|
os.chmod(dest, mode)
|
|
|
|
except IOError:
|
2009-04-16 15:25:57 +00:00
|
|
|
_error('Cannot copy file %s to %s', src, dest)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2014-07-16 11:56:40 +00:00
|
|
|
class _LinkFile(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2015-06-03 15:05:17 +00:00
|
|
|
def __init__(self, git_worktree, src, dest, relsrc, absdest):
|
|
|
|
self.git_worktree = git_worktree
|
2014-04-21 22:10:59 +00:00
|
|
|
self.src = src
|
|
|
|
self.dest = dest
|
2015-05-05 07:24:54 +00:00
|
|
|
self.src_rel_to_dest = relsrc
|
2014-04-21 22:10:59 +00:00
|
|
|
self.abs_dest = absdest
|
|
|
|
|
2015-06-03 15:05:17 +00:00
|
|
|
def __linkIt(self, relSrc, absDest):
|
2014-04-21 22:10:59 +00:00
|
|
|
# link file if it does not exist or is out of date
|
2016-11-01 21:37:13 +00:00
|
|
|
if not platform_utils.islink(absDest) or (platform_utils.readlink(absDest) != relSrc):
|
2014-04-21 22:10:59 +00:00
|
|
|
try:
|
|
|
|
# remove existing file first, since it might be read-only
|
2015-11-19 00:49:38 +00:00
|
|
|
if os.path.lexists(absDest):
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(absDest)
|
2014-04-21 22:10:59 +00:00
|
|
|
else:
|
2015-06-03 15:05:17 +00:00
|
|
|
dest_dir = os.path.dirname(absDest)
|
2018-09-27 17:46:58 +00:00
|
|
|
if not platform_utils.isdir(dest_dir):
|
2014-04-21 22:10:59 +00:00
|
|
|
os.makedirs(dest_dir)
|
2016-11-01 18:24:03 +00:00
|
|
|
platform_utils.symlink(relSrc, absDest)
|
2014-04-21 22:10:59 +00:00
|
|
|
except IOError:
|
2015-06-03 15:05:17 +00:00
|
|
|
_error('Cannot link file %s to %s', relSrc, absDest)
|
|
|
|
|
|
|
|
def _Link(self):
|
|
|
|
"""Link the self.rel_src_to_dest and self.abs_dest. Handles wild cards
|
|
|
|
on the src linking all of the files in the source in to the destination
|
|
|
|
directory.
|
|
|
|
"""
|
|
|
|
# We use the absSrc to handle the situation where the current directory
|
|
|
|
# is not the root of the repo
|
|
|
|
absSrc = os.path.join(self.git_worktree, self.src)
|
|
|
|
if os.path.exists(absSrc):
|
|
|
|
# Entity exists so just a simple one to one link operation
|
|
|
|
self.__linkIt(self.src_rel_to_dest, self.abs_dest)
|
|
|
|
else:
|
|
|
|
# Entity doesn't exist assume there is a wild card
|
|
|
|
absDestDir = self.abs_dest
|
2018-09-27 17:46:58 +00:00
|
|
|
if os.path.exists(absDestDir) and not platform_utils.isdir(absDestDir):
|
2015-06-03 15:05:17 +00:00
|
|
|
_error('Link error: src with wildcard, %s must be a directory',
|
2016-02-10 17:44:30 +00:00
|
|
|
absDestDir)
|
2015-06-03 15:05:17 +00:00
|
|
|
else:
|
|
|
|
absSrcFiles = glob.glob(absSrc)
|
|
|
|
for absSrcFile in absSrcFiles:
|
|
|
|
# Create a releative path from source dir to destination dir
|
|
|
|
absSrcDir = os.path.dirname(absSrcFile)
|
|
|
|
relSrcDir = os.path.relpath(absSrcDir, absDestDir)
|
|
|
|
|
|
|
|
# Get the source file name
|
|
|
|
srcFile = os.path.basename(absSrcFile)
|
|
|
|
|
|
|
|
# Now form the final full paths to srcFile. They will be
|
|
|
|
# absolute for the desintaiton and relative for the srouce.
|
|
|
|
absDest = os.path.join(absDestDir, srcFile)
|
|
|
|
relSrc = os.path.join(relSrcDir, srcFile)
|
|
|
|
self.__linkIt(relSrc, absDest)
|
2014-04-21 22:10:59 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2009-05-19 21:58:02 +00:00
|
|
|
class RemoteSpec(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2009-05-19 21:58:02 +00:00
|
|
|
def __init__(self,
|
|
|
|
name,
|
2014-07-16 11:56:40 +00:00
|
|
|
url=None,
|
2016-08-10 22:00:00 +00:00
|
|
|
pushUrl=None,
|
2014-07-16 11:56:40 +00:00
|
|
|
review=None,
|
2016-04-06 23:03:54 +00:00
|
|
|
revision=None,
|
2017-04-05 07:02:59 +00:00
|
|
|
orig_name=None,
|
|
|
|
fetchUrl=None):
|
2009-05-19 21:58:02 +00:00
|
|
|
self.name = name
|
|
|
|
self.url = url
|
2016-08-10 22:00:00 +00:00
|
|
|
self.pushUrl = pushUrl
|
2009-05-19 21:58:02 +00:00
|
|
|
self.review = review
|
2014-05-06 10:54:01 +00:00
|
|
|
self.revision = revision
|
2016-04-06 23:03:54 +00:00
|
|
|
self.orig_name = orig_name
|
2017-04-05 07:02:59 +00:00
|
|
|
self.fetchUrl = fetchUrl
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
class RepoHook(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
"""A RepoHook contains information about a script to run as a hook.
|
|
|
|
|
|
|
|
Hooks are used to run a python script before running an upload (for instance,
|
|
|
|
to run presubmit checks). Eventually, we may have hooks for other actions.
|
|
|
|
|
|
|
|
This shouldn't be confused with files in the 'repo/hooks' directory. Those
|
|
|
|
files are copied into each '.git/hooks' folder for each project. Repo-level
|
|
|
|
hooks are associated instead with repo actions.
|
|
|
|
|
|
|
|
Hooks are always python. When a hook is run, we will load the hook into the
|
|
|
|
interpreter and execute its main() function.
|
|
|
|
"""
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
def __init__(self,
|
|
|
|
hook_type,
|
|
|
|
hooks_project,
|
|
|
|
topdir,
|
2016-08-16 01:23:44 +00:00
|
|
|
manifest_url,
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
abort_if_user_denies=False):
|
|
|
|
"""RepoHook constructor.
|
|
|
|
|
|
|
|
Params:
|
|
|
|
hook_type: A string representing the type of hook. This is also used
|
|
|
|
to figure out the name of the file containing the hook. For
|
|
|
|
example: 'pre-upload'.
|
|
|
|
hooks_project: The project containing the repo hooks. If you have a
|
|
|
|
manifest, this is manifest.repo_hooks_project. OK if this is None,
|
|
|
|
which will make the hook a no-op.
|
|
|
|
topdir: Repo's top directory (the one containing the .repo directory).
|
|
|
|
Scripts will run with CWD as this directory. If you have a manifest,
|
|
|
|
this is manifest.topdir
|
2016-08-16 01:23:44 +00:00
|
|
|
manifest_url: The URL to the manifest git repo.
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
abort_if_user_denies: If True, we'll throw a HookError() if the user
|
|
|
|
doesn't allow us to run the hook.
|
|
|
|
"""
|
|
|
|
self._hook_type = hook_type
|
|
|
|
self._hooks_project = hooks_project
|
2016-08-16 01:23:44 +00:00
|
|
|
self._manifest_url = manifest_url
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
self._topdir = topdir
|
|
|
|
self._abort_if_user_denies = abort_if_user_denies
|
|
|
|
|
|
|
|
# Store the full path to the script for convenience.
|
|
|
|
if self._hooks_project:
|
|
|
|
self._script_fullpath = os.path.join(self._hooks_project.worktree,
|
|
|
|
self._hook_type + '.py')
|
|
|
|
else:
|
|
|
|
self._script_fullpath = None
|
|
|
|
|
|
|
|
def _GetHash(self):
|
|
|
|
"""Return a hash of the contents of the hooks directory.
|
|
|
|
|
|
|
|
We'll just use git to do this. This hash has the property that if anything
|
|
|
|
changes in the directory we will return a different has.
|
|
|
|
|
|
|
|
SECURITY CONSIDERATION:
|
|
|
|
This hash only represents the contents of files in the hook directory, not
|
|
|
|
any other files imported or called by hooks. Changes to imported files
|
|
|
|
can change the script behavior without affecting the hash.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
A string representing the hash. This will always be ASCII so that it can
|
|
|
|
be printed to the user easily.
|
|
|
|
"""
|
|
|
|
assert self._hooks_project, "Must have hooks to calculate their hash."
|
|
|
|
|
|
|
|
# We will use the work_git object rather than just calling GetRevisionId().
|
|
|
|
# That gives us a hash of the latest checked in version of the files that
|
|
|
|
# the user will actually be executing. Specifically, GetRevisionId()
|
|
|
|
# doesn't appear to change even if a user checks out a different version
|
|
|
|
# of the hooks repo (via git checkout) nor if a user commits their own revs.
|
|
|
|
#
|
|
|
|
# NOTE: Local (non-committed) changes will not be factored into this hash.
|
|
|
|
# I think this is OK, since we're really only worried about warning the user
|
|
|
|
# about upstream changes.
|
|
|
|
return self._hooks_project.work_git.rev_parse('HEAD')
|
|
|
|
|
|
|
|
def _GetMustVerb(self):
|
|
|
|
"""Return 'must' if the hook is required; 'should' if not."""
|
|
|
|
if self._abort_if_user_denies:
|
|
|
|
return 'must'
|
|
|
|
else:
|
|
|
|
return 'should'
|
|
|
|
|
|
|
|
def _CheckForHookApproval(self):
|
|
|
|
"""Check to see whether this hook has been approved.
|
|
|
|
|
2016-08-16 01:23:44 +00:00
|
|
|
We'll accept approval of manifest URLs if they're using secure transports.
|
|
|
|
This way the user can say they trust the manifest hoster. For insecure
|
|
|
|
hosts, we fall back to checking the hash of the hooks repo.
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
|
|
|
|
Note that we ask permission for each individual hook even though we use
|
|
|
|
the hash of all hooks when detecting changes. We'd like the user to be
|
|
|
|
able to approve / deny each hook individually. We only use the hash of all
|
|
|
|
hooks because there is no other easy way to detect changes to local imports.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
True if this hook is approved to run; False otherwise.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
HookError: Raised if the user doesn't approve and abort_if_user_denies
|
|
|
|
was passed to the consturctor.
|
|
|
|
"""
|
2016-08-16 01:23:44 +00:00
|
|
|
if self._ManifestUrlHasSecureScheme():
|
|
|
|
return self._CheckForHookApprovalManifest()
|
|
|
|
else:
|
|
|
|
return self._CheckForHookApprovalHash()
|
|
|
|
|
|
|
|
def _CheckForHookApprovalHelper(self, subkey, new_val, main_prompt,
|
|
|
|
changed_prompt):
|
|
|
|
"""Check for approval for a particular attribute and hook.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
subkey: The git config key under [repo.hooks.<hook_type>] to store the
|
|
|
|
last approved string.
|
|
|
|
new_val: The new value to compare against the last approved one.
|
|
|
|
main_prompt: Message to display to the user to ask for approval.
|
|
|
|
changed_prompt: Message explaining why we're re-asking for approval.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
True if this hook is approved to run; False otherwise.
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
|
2016-08-16 01:23:44 +00:00
|
|
|
Raises:
|
|
|
|
HookError: Raised if the user doesn't approve and abort_if_user_denies
|
|
|
|
was passed to the consturctor.
|
|
|
|
"""
|
|
|
|
hooks_config = self._hooks_project.config
|
|
|
|
git_approval_key = 'repo.hooks.%s.%s' % (self._hook_type, subkey)
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
|
2016-08-16 01:23:44 +00:00
|
|
|
# Get the last value that the user approved for this hook; may be None.
|
|
|
|
old_val = hooks_config.GetString(git_approval_key)
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
|
2016-08-16 01:23:44 +00:00
|
|
|
if old_val is not None:
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
# User previously approved hook and asked not to be prompted again.
|
2016-08-16 01:23:44 +00:00
|
|
|
if new_val == old_val:
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
# Approval matched. We're done.
|
|
|
|
return True
|
|
|
|
else:
|
|
|
|
# Give the user a reason why we're prompting, since they last told
|
|
|
|
# us to "never ask again".
|
2016-08-16 01:23:44 +00:00
|
|
|
prompt = 'WARNING: %s\n\n' % (changed_prompt,)
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
else:
|
|
|
|
prompt = ''
|
|
|
|
|
|
|
|
# Prompt the user if we're not on a tty; on a tty we'll assume "no".
|
|
|
|
if sys.stdout.isatty():
|
2016-08-16 01:23:44 +00:00
|
|
|
prompt += main_prompt + ' (yes/always/NO)? '
|
2013-03-01 13:44:38 +00:00
|
|
|
response = input(prompt).lower()
|
2012-11-14 02:18:00 +00:00
|
|
|
print()
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
|
|
|
|
# User is doing a one-time approval.
|
|
|
|
if response in ('y', 'yes'):
|
|
|
|
return True
|
2016-08-16 01:23:44 +00:00
|
|
|
elif response == 'always':
|
|
|
|
hooks_config.SetString(git_approval_key, new_val)
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
return True
|
|
|
|
|
|
|
|
# For anything else, we'll assume no approval.
|
|
|
|
if self._abort_if_user_denies:
|
|
|
|
raise HookError('You must allow the %s hook or use --no-verify.' %
|
|
|
|
self._hook_type)
|
|
|
|
|
|
|
|
return False
|
|
|
|
|
2016-08-16 01:23:44 +00:00
|
|
|
def _ManifestUrlHasSecureScheme(self):
|
|
|
|
"""Check if the URI for the manifest is a secure transport."""
|
|
|
|
secure_schemes = ('file', 'https', 'ssh', 'persistent-https', 'sso', 'rpc')
|
|
|
|
parse_results = urllib.parse.urlparse(self._manifest_url)
|
|
|
|
return parse_results.scheme in secure_schemes
|
|
|
|
|
|
|
|
def _CheckForHookApprovalManifest(self):
|
|
|
|
"""Check whether the user has approved this manifest host.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
True if this hook is approved to run; False otherwise.
|
|
|
|
"""
|
|
|
|
return self._CheckForHookApprovalHelper(
|
|
|
|
'approvedmanifest',
|
|
|
|
self._manifest_url,
|
|
|
|
'Run hook scripts from %s' % (self._manifest_url,),
|
|
|
|
'Manifest URL has changed since %s was allowed.' % (self._hook_type,))
|
|
|
|
|
|
|
|
def _CheckForHookApprovalHash(self):
|
|
|
|
"""Check whether the user has approved the hooks repo.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
True if this hook is approved to run; False otherwise.
|
|
|
|
"""
|
|
|
|
prompt = ('Repo %s run the script:\n'
|
|
|
|
' %s\n'
|
|
|
|
'\n'
|
2016-08-16 19:05:09 +00:00
|
|
|
'Do you want to allow this script to run')
|
2016-08-16 01:23:44 +00:00
|
|
|
return self._CheckForHookApprovalHelper(
|
|
|
|
'approvedhash',
|
|
|
|
self._GetHash(),
|
2016-08-16 19:05:09 +00:00
|
|
|
prompt % (self._GetMustVerb(), self._script_fullpath),
|
2016-08-16 01:23:44 +00:00
|
|
|
'Scripts have changed since %s was allowed.' % (self._hook_type,))
|
|
|
|
|
2019-06-18 21:23:39 +00:00
|
|
|
@staticmethod
|
|
|
|
def _ExtractInterpFromShebang(data):
|
|
|
|
"""Extract the interpreter used in the shebang.
|
|
|
|
|
|
|
|
Try to locate the interpreter the script is using (ignoring `env`).
|
|
|
|
|
|
|
|
Args:
|
|
|
|
data: The file content of the script.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The basename of the main script interpreter, or None if a shebang is not
|
|
|
|
used or could not be parsed out.
|
|
|
|
"""
|
|
|
|
firstline = data.splitlines()[:1]
|
|
|
|
if not firstline:
|
|
|
|
return None
|
|
|
|
|
|
|
|
# The format here can be tricky.
|
|
|
|
shebang = firstline[0].strip()
|
|
|
|
m = re.match(r'^#!\s*([^\s]+)(?:\s+([^\s]+))?', shebang)
|
|
|
|
if not m:
|
|
|
|
return None
|
|
|
|
|
|
|
|
# If the using `env`, find the target program.
|
|
|
|
interp = m.group(1)
|
|
|
|
if os.path.basename(interp) == 'env':
|
|
|
|
interp = m.group(2)
|
|
|
|
|
|
|
|
return interp
|
|
|
|
|
|
|
|
def _ExecuteHookViaReexec(self, interp, context, **kwargs):
|
|
|
|
"""Execute the hook script through |interp|.
|
|
|
|
|
|
|
|
Note: Support for this feature should be dropped ~Jun 2021.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
interp: The Python program to run.
|
|
|
|
context: Basic Python context to execute the hook inside.
|
|
|
|
kwargs: Arbitrary arguments to pass to the hook script.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
HookError: When the hooks failed for any reason.
|
|
|
|
"""
|
|
|
|
# This logic needs to be kept in sync with _ExecuteHookViaImport below.
|
|
|
|
script = """
|
|
|
|
import json, os, sys
|
|
|
|
path = '''%(path)s'''
|
|
|
|
kwargs = json.loads('''%(kwargs)s''')
|
|
|
|
context = json.loads('''%(context)s''')
|
|
|
|
sys.path.insert(0, os.path.dirname(path))
|
|
|
|
data = open(path).read()
|
|
|
|
exec(compile(data, path, 'exec'), context)
|
|
|
|
context['main'](**kwargs)
|
|
|
|
""" % {
|
|
|
|
'path': self._script_fullpath,
|
|
|
|
'kwargs': json.dumps(kwargs),
|
|
|
|
'context': json.dumps(context),
|
|
|
|
}
|
|
|
|
|
|
|
|
# We pass the script via stdin to avoid OS argv limits. It also makes
|
|
|
|
# unhandled exception tracebacks less verbose/confusing for users.
|
|
|
|
cmd = [interp, '-c', 'import sys; exec(sys.stdin.read())']
|
|
|
|
proc = subprocess.Popen(cmd, stdin=subprocess.PIPE)
|
|
|
|
proc.communicate(input=script.encode('utf-8'))
|
|
|
|
if proc.returncode:
|
|
|
|
raise HookError('Failed to run %s hook.' % (self._hook_type,))
|
|
|
|
|
|
|
|
def _ExecuteHookViaImport(self, data, context, **kwargs):
|
|
|
|
"""Execute the hook code in |data| directly.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
data: The code of the hook to execute.
|
|
|
|
context: Basic Python context to execute the hook inside.
|
|
|
|
kwargs: Arbitrary arguments to pass to the hook script.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
HookError: When the hooks failed for any reason.
|
|
|
|
"""
|
|
|
|
# Exec, storing global context in the context dict. We catch exceptions
|
|
|
|
# and convert to a HookError w/ just the failing traceback.
|
|
|
|
try:
|
|
|
|
exec(compile(data, self._script_fullpath, 'exec'), context)
|
|
|
|
except Exception:
|
|
|
|
raise HookError('%s\nFailed to import %s hook; see traceback above.' %
|
|
|
|
(traceback.format_exc(), self._hook_type))
|
|
|
|
|
|
|
|
# Running the script should have defined a main() function.
|
|
|
|
if 'main' not in context:
|
|
|
|
raise HookError('Missing main() in: "%s"' % self._script_fullpath)
|
|
|
|
|
|
|
|
# Call the main function in the hook. If the hook should cause the
|
|
|
|
# build to fail, it will raise an Exception. We'll catch that convert
|
|
|
|
# to a HookError w/ just the failing traceback.
|
|
|
|
try:
|
|
|
|
context['main'](**kwargs)
|
|
|
|
except Exception:
|
|
|
|
raise HookError('%s\nFailed to run main() for %s hook; see traceback '
|
|
|
|
'above.' % (traceback.format_exc(), self._hook_type))
|
|
|
|
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
def _ExecuteHook(self, **kwargs):
|
|
|
|
"""Actually execute the given hook.
|
|
|
|
|
|
|
|
This will run the hook's 'main' function in our python interpreter.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
kwargs: Keyword arguments to pass to the hook. These are often specific
|
|
|
|
to the hook type. For instance, pre-upload hooks will contain
|
|
|
|
a project_list.
|
|
|
|
"""
|
|
|
|
# Keep sys.path and CWD stashed away so that we can always restore them
|
|
|
|
# upon function exit.
|
|
|
|
orig_path = os.getcwd()
|
|
|
|
orig_syspath = sys.path
|
|
|
|
|
|
|
|
try:
|
|
|
|
# Always run hooks with CWD as topdir.
|
|
|
|
os.chdir(self._topdir)
|
|
|
|
|
|
|
|
# Put the hook dir as the first item of sys.path so hooks can do
|
|
|
|
# relative imports. We want to replace the repo dir as [0] so
|
|
|
|
# hooks can't import repo files.
|
|
|
|
sys.path = [os.path.dirname(self._script_fullpath)] + sys.path[1:]
|
|
|
|
|
2019-06-18 21:23:39 +00:00
|
|
|
# Initial global context for the hook to run within.
|
2016-03-04 20:03:00 +00:00
|
|
|
context = {'__file__': self._script_fullpath}
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
|
|
|
|
# Add 'hook_should_take_kwargs' to the arguments to be passed to main.
|
|
|
|
# We don't actually want hooks to define their main with this argument--
|
|
|
|
# it's there to remind them that their hook should always take **kwargs.
|
|
|
|
# For instance, a pre-upload hook should be defined like:
|
|
|
|
# def main(project_list, **kwargs):
|
|
|
|
#
|
|
|
|
# This allows us to later expand the API without breaking old hooks.
|
|
|
|
kwargs = kwargs.copy()
|
|
|
|
kwargs['hook_should_take_kwargs'] = True
|
|
|
|
|
2019-06-18 21:23:39 +00:00
|
|
|
# See what version of python the hook has been written against.
|
|
|
|
data = open(self._script_fullpath).read()
|
|
|
|
interp = self._ExtractInterpFromShebang(data)
|
|
|
|
reexec = False
|
|
|
|
if interp:
|
|
|
|
prog = os.path.basename(interp)
|
|
|
|
if prog.startswith('python2') and sys.version_info.major != 2:
|
|
|
|
reexec = True
|
|
|
|
elif prog.startswith('python3') and sys.version_info.major == 2:
|
|
|
|
reexec = True
|
|
|
|
|
|
|
|
# Attempt to execute the hooks through the requested version of Python.
|
|
|
|
if reexec:
|
|
|
|
try:
|
|
|
|
self._ExecuteHookViaReexec(interp, context, **kwargs)
|
|
|
|
except OSError as e:
|
|
|
|
if e.errno == errno.ENOENT:
|
|
|
|
# We couldn't find the interpreter, so fallback to importing.
|
|
|
|
reexec = False
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
|
|
|
|
# Run the hook by importing directly.
|
|
|
|
if not reexec:
|
|
|
|
self._ExecuteHookViaImport(data, context, **kwargs)
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
finally:
|
|
|
|
# Restore sys.path and CWD.
|
|
|
|
sys.path = orig_syspath
|
|
|
|
os.chdir(orig_path)
|
|
|
|
|
|
|
|
def Run(self, user_allows_all_hooks, **kwargs):
|
|
|
|
"""Run the hook.
|
|
|
|
|
|
|
|
If the hook doesn't exist (because there is no hooks project or because
|
|
|
|
this particular hook is not enabled), this is a no-op.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
user_allows_all_hooks: If True, we will never prompt about running the
|
|
|
|
hook--we'll just assume it's OK to run it.
|
|
|
|
kwargs: Keyword arguments to pass to the hook. These are often specific
|
|
|
|
to the hook type. For instance, pre-upload hooks will contain
|
|
|
|
a project_list.
|
|
|
|
|
|
|
|
Raises:
|
|
|
|
HookError: If there was a problem finding the hook or the user declined
|
|
|
|
to run a required hook (from _CheckForHookApproval).
|
|
|
|
"""
|
|
|
|
# No-op if there is no hooks project or if hook is disabled.
|
2016-02-10 17:44:30 +00:00
|
|
|
if ((not self._hooks_project) or (self._hook_type not in
|
|
|
|
self._hooks_project.enabled_repo_hooks)):
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
return
|
|
|
|
|
|
|
|
# Bail with a nice error if we can't find the hook.
|
|
|
|
if not os.path.isfile(self._script_fullpath):
|
|
|
|
raise HookError('Couldn\'t find repo hook: "%s"' % self._script_fullpath)
|
|
|
|
|
|
|
|
# Make sure the user is OK with running the hook.
|
|
|
|
if (not user_allows_all_hooks) and (not self._CheckForHookApproval()):
|
|
|
|
return
|
|
|
|
|
|
|
|
# Run the hook with the same version of python we're using.
|
|
|
|
self._ExecuteHook(**kwargs)
|
|
|
|
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
class Project(object):
|
2014-10-16 22:02:58 +00:00
|
|
|
# These objects can be shared between several working trees.
|
|
|
|
shareable_files = ['description', 'info']
|
|
|
|
shareable_dirs = ['hooks', 'objects', 'rr-cache', 'svn']
|
|
|
|
# These objects can only be used by a single working tree.
|
|
|
|
working_tree_files = ['config', 'packed-refs', 'shallow']
|
|
|
|
working_tree_dirs = ['logs', 'refs']
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def __init__(self,
|
|
|
|
manifest,
|
|
|
|
name,
|
|
|
|
remote,
|
|
|
|
gitdir,
|
2013-10-12 00:03:19 +00:00
|
|
|
objdir,
|
2008-10-21 14:00:00 +00:00
|
|
|
worktree,
|
|
|
|
relpath,
|
2009-05-30 01:38:17 +00:00
|
|
|
revisionExpr,
|
2012-02-28 19:53:24 +00:00
|
|
|
revisionId,
|
2014-07-16 11:56:40 +00:00
|
|
|
rebase=True,
|
|
|
|
groups=None,
|
|
|
|
sync_c=False,
|
|
|
|
sync_s=False,
|
2018-02-14 07:57:31 +00:00
|
|
|
sync_tags=True,
|
2014-07-16 11:56:40 +00:00
|
|
|
clone_depth=None,
|
|
|
|
upstream=None,
|
|
|
|
parent=None,
|
|
|
|
is_derived=False,
|
2014-09-04 12:28:09 +00:00
|
|
|
dest_branch=None,
|
2015-08-20 19:19:28 +00:00
|
|
|
optimized_fetch=False,
|
|
|
|
old_revision=None):
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
"""Init a Project object.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
manifest: The XmlManifest object.
|
|
|
|
name: The `name` attribute of manifest.xml's project element.
|
|
|
|
remote: RemoteSpec object specifying its remote's properties.
|
|
|
|
gitdir: Absolute path of git directory.
|
2013-10-12 00:03:19 +00:00
|
|
|
objdir: Absolute path of directory to store git objects.
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
worktree: Absolute path of git working tree.
|
|
|
|
relpath: Relative path of git working tree to repo's top directory.
|
|
|
|
revisionExpr: The `revision` attribute of manifest.xml's project element.
|
|
|
|
revisionId: git commit id for checking out.
|
|
|
|
rebase: The `rebase` attribute of manifest.xml's project element.
|
|
|
|
groups: The `groups` attribute of manifest.xml's project element.
|
|
|
|
sync_c: The `sync-c` attribute of manifest.xml's project element.
|
|
|
|
sync_s: The `sync-s` attribute of manifest.xml's project element.
|
2018-02-14 07:57:31 +00:00
|
|
|
sync_tags: The `sync-tags` attribute of manifest.xml's project element.
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
upstream: The `upstream` attribute of manifest.xml's project element.
|
|
|
|
parent: The parent Project object.
|
|
|
|
is_derived: False if the project was explicitly defined in the manifest;
|
|
|
|
True if the project is a discovered submodule.
|
2013-05-06 17:36:24 +00:00
|
|
|
dest_branch: The branch to which to push changes for review by default.
|
2014-09-04 12:28:09 +00:00
|
|
|
optimized_fetch: If True, when a project is set to a sha1 revision, only
|
|
|
|
fetch from the remote if the sha1 is not present locally.
|
2015-08-20 19:19:28 +00:00
|
|
|
old_revision: saved git commit id for open GITC projects.
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
"""
|
2008-10-21 14:00:00 +00:00
|
|
|
self.manifest = manifest
|
|
|
|
self.name = name
|
|
|
|
self.remote = remote
|
2011-01-10 01:31:57 +00:00
|
|
|
self.gitdir = gitdir.replace('\\', '/')
|
2013-10-12 00:03:19 +00:00
|
|
|
self.objdir = objdir.replace('\\', '/')
|
2011-01-10 21:26:01 +00:00
|
|
|
if worktree:
|
2016-11-02 01:28:01 +00:00
|
|
|
self.worktree = os.path.normpath(worktree).replace('\\', '/')
|
2011-01-10 21:26:01 +00:00
|
|
|
else:
|
|
|
|
self.worktree = None
|
2008-10-21 14:00:00 +00:00
|
|
|
self.relpath = relpath
|
2009-05-30 01:38:17 +00:00
|
|
|
self.revisionExpr = revisionExpr
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
if revisionId is None \
|
|
|
|
and revisionExpr \
|
|
|
|
and IsId(revisionExpr):
|
2009-05-30 01:38:17 +00:00
|
|
|
self.revisionId = revisionExpr
|
|
|
|
else:
|
|
|
|
self.revisionId = revisionId
|
|
|
|
|
2012-02-28 19:53:24 +00:00
|
|
|
self.rebase = rebase
|
2012-03-29 03:15:45 +00:00
|
|
|
self.groups = groups
|
2012-04-20 21:41:59 +00:00
|
|
|
self.sync_c = sync_c
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
self.sync_s = sync_s
|
2018-02-14 07:57:31 +00:00
|
|
|
self.sync_tags = sync_tags
|
2012-11-27 13:25:30 +00:00
|
|
|
self.clone_depth = clone_depth
|
2012-09-29 03:21:57 +00:00
|
|
|
self.upstream = upstream
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
self.parent = parent
|
|
|
|
self.is_derived = is_derived
|
2014-09-04 12:28:09 +00:00
|
|
|
self.optimized_fetch = optimized_fetch
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
self.subprojects = []
|
2012-02-28 19:53:24 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
self.snapshots = {}
|
|
|
|
self.copyfiles = []
|
2014-04-21 22:10:59 +00:00
|
|
|
self.linkfiles = []
|
2012-04-12 20:04:13 +00:00
|
|
|
self.annotations = []
|
2016-02-10 17:44:30 +00:00
|
|
|
self.config = GitConfig.ForRepository(gitdir=self.gitdir,
|
|
|
|
defaults=self.manifest.globalConfig)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2008-11-04 15:37:10 +00:00
|
|
|
if self.worktree:
|
2013-10-12 00:03:19 +00:00
|
|
|
self.work_git = self._GitGetByExec(self, bare=False, gitdir=gitdir)
|
2008-11-04 15:37:10 +00:00
|
|
|
else:
|
|
|
|
self.work_git = None
|
2013-10-12 00:03:19 +00:00
|
|
|
self.bare_git = self._GitGetByExec(self, bare=True, gitdir=gitdir)
|
2009-04-18 01:49:50 +00:00
|
|
|
self.bare_ref = GitRefs(gitdir)
|
2013-10-12 00:03:19 +00:00
|
|
|
self.bare_objdir = self._GitGetByExec(self, bare=True, gitdir=objdir)
|
2013-05-06 17:36:24 +00:00
|
|
|
self.dest_branch = dest_branch
|
2015-08-20 19:19:28 +00:00
|
|
|
self.old_revision = old_revision
|
2008-10-21 14:00:00 +00:00
|
|
|
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
# This will be filled in if a project is later identified to be the
|
|
|
|
# project containing repo hooks.
|
|
|
|
self.enabled_repo_hooks = []
|
|
|
|
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
@property
|
|
|
|
def Derived(self):
|
|
|
|
return self.is_derived
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
@property
|
|
|
|
def Exists(self):
|
2018-09-27 17:46:58 +00:00
|
|
|
return platform_utils.isdir(self.gitdir) and platform_utils.isdir(self.objdir)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
@property
|
|
|
|
def CurrentBranch(self):
|
|
|
|
"""Obtain the name of the currently checked out branch.
|
2019-10-01 05:07:11 +00:00
|
|
|
|
|
|
|
The branch name omits the 'refs/heads/' prefix.
|
|
|
|
None is returned if the project is on a detached HEAD, or if the work_git is
|
|
|
|
otheriwse inaccessible (e.g. an incomplete sync).
|
2008-10-21 14:00:00 +00:00
|
|
|
"""
|
2019-10-01 05:07:11 +00:00
|
|
|
try:
|
|
|
|
b = self.work_git.GetHead()
|
|
|
|
except NoManifestException:
|
|
|
|
# If the local checkout is in a bad state, don't barf. Let the callers
|
|
|
|
# process this like the head is unreadable.
|
|
|
|
return None
|
2008-10-21 14:00:00 +00:00
|
|
|
if b.startswith(R_HEADS):
|
|
|
|
return b[len(R_HEADS):]
|
|
|
|
return None
|
|
|
|
|
2009-04-18 22:26:10 +00:00
|
|
|
def IsRebaseInProgress(self):
|
|
|
|
w = self.worktree
|
|
|
|
g = os.path.join(w, '.git')
|
|
|
|
return os.path.exists(os.path.join(g, 'rebase-apply')) \
|
|
|
|
or os.path.exists(os.path.join(g, 'rebase-merge')) \
|
|
|
|
or os.path.exists(os.path.join(w, '.dotest'))
|
2010-06-17 15:55:02 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def IsDirty(self, consider_untracked=True):
|
|
|
|
"""Is the working directory modified in some way?
|
|
|
|
"""
|
|
|
|
self.work_git.update_index('-q',
|
|
|
|
'--unmerged',
|
|
|
|
'--ignore-missing',
|
|
|
|
'--refresh')
|
2012-11-14 03:09:38 +00:00
|
|
|
if self.work_git.DiffZ('diff-index', '-M', '--cached', HEAD):
|
2008-10-21 14:00:00 +00:00
|
|
|
return True
|
|
|
|
if self.work_git.DiffZ('diff-files'):
|
|
|
|
return True
|
|
|
|
if consider_untracked and self.work_git.LsOthers():
|
|
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
|
|
_userident_name = None
|
|
|
|
_userident_email = None
|
|
|
|
|
|
|
|
@property
|
|
|
|
def UserName(self):
|
|
|
|
"""Obtain the user's personal name.
|
|
|
|
"""
|
|
|
|
if self._userident_name is None:
|
|
|
|
self._LoadUserIdentity()
|
|
|
|
return self._userident_name
|
|
|
|
|
|
|
|
@property
|
|
|
|
def UserEmail(self):
|
|
|
|
"""Obtain the user's email address. This is very likely
|
|
|
|
to be their Gerrit login.
|
|
|
|
"""
|
|
|
|
if self._userident_email is None:
|
|
|
|
self._LoadUserIdentity()
|
|
|
|
return self._userident_email
|
|
|
|
|
|
|
|
def _LoadUserIdentity(self):
|
2012-11-14 02:36:51 +00:00
|
|
|
u = self.bare_git.var('GIT_COMMITTER_IDENT')
|
|
|
|
m = re.compile("^(.*) <([^>]*)> ").match(u)
|
|
|
|
if m:
|
|
|
|
self._userident_name = m.group(1)
|
|
|
|
self._userident_email = m.group(2)
|
|
|
|
else:
|
|
|
|
self._userident_name = ''
|
|
|
|
self._userident_email = ''
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
def GetRemote(self, name):
|
|
|
|
"""Get the configuration for a single remote.
|
|
|
|
"""
|
|
|
|
return self.config.GetRemote(name)
|
|
|
|
|
|
|
|
def GetBranch(self, name):
|
|
|
|
"""Get the configuration for a single branch.
|
|
|
|
"""
|
|
|
|
return self.config.GetBranch(name)
|
|
|
|
|
2009-04-10 23:02:48 +00:00
|
|
|
def GetBranches(self):
|
|
|
|
"""Get all existing local branches.
|
|
|
|
"""
|
|
|
|
current = self.CurrentBranch
|
2012-09-24 03:15:13 +00:00
|
|
|
all_refs = self._allrefs
|
2009-04-10 23:02:48 +00:00
|
|
|
heads = {}
|
|
|
|
|
2013-03-01 13:44:38 +00:00
|
|
|
for name, ref_id in all_refs.items():
|
2009-04-10 23:02:48 +00:00
|
|
|
if name.startswith(R_HEADS):
|
|
|
|
name = name[len(R_HEADS):]
|
|
|
|
b = self.GetBranch(name)
|
|
|
|
b.current = name == current
|
|
|
|
b.published = None
|
2012-09-24 03:15:13 +00:00
|
|
|
b.revision = ref_id
|
2009-04-10 23:02:48 +00:00
|
|
|
heads[name] = b
|
|
|
|
|
2013-03-01 13:44:38 +00:00
|
|
|
for name, ref_id in all_refs.items():
|
2009-04-10 23:02:48 +00:00
|
|
|
if name.startswith(R_PUB):
|
|
|
|
name = name[len(R_PUB):]
|
|
|
|
b = heads.get(name)
|
|
|
|
if b:
|
2012-09-24 03:15:13 +00:00
|
|
|
b.published = ref_id
|
2009-04-10 23:02:48 +00:00
|
|
|
|
|
|
|
return heads
|
|
|
|
|
2012-03-29 03:15:45 +00:00
|
|
|
def MatchesGroups(self, manifest_groups):
|
|
|
|
"""Returns true if the manifest groups specified at init should cause
|
|
|
|
this project to be synced.
|
|
|
|
Prefixing a manifest group with "-" inverts the meaning of a group.
|
2012-08-13 20:11:18 +00:00
|
|
|
All projects are implicitly labelled with "all".
|
2012-03-29 03:15:45 +00:00
|
|
|
|
2012-04-16 17:36:08 +00:00
|
|
|
labels are resolved in order. In the example case of
|
2012-08-13 20:11:18 +00:00
|
|
|
project_groups: "all,group1,group2"
|
2012-04-16 17:36:08 +00:00
|
|
|
manifest_groups: "-group1,group2"
|
|
|
|
the project will be matched.
|
Special handling for manifest group "default"
Change Details:
* Make "default" a special manifest group that matches any project that
does not have the special project group "notdefault"
* Use "default" instead of "all,-notdefault" when user does not specify
manifest group
* Expand -g option help to include example usage of manifest groups
Change Benefits:
* Allow a more intuitive and expressive manifest groups specification:
* "default" instead of "all,-notdefault"
* "default,foo" instead of "all,-notdefault,foo"
* "default,-foo" instead of "all,-notdefault,-foo"
* "foo,-default" which has no equivalent
* Default manifest groups behavior can be restored by the command
'repo init -g default'. This is significantly more intuitive than the
current equivalent command 'repo init -g all,-notdefault'.
Change-Id: I6d0673791d64a650110a917c248bcebb23b279d3
2012-11-15 00:19:00 +00:00
|
|
|
|
|
|
|
The special manifest group "default" will match any project that
|
|
|
|
does not have the special project group "notdefault"
|
2012-04-16 17:36:08 +00:00
|
|
|
"""
|
Special handling for manifest group "default"
Change Details:
* Make "default" a special manifest group that matches any project that
does not have the special project group "notdefault"
* Use "default" instead of "all,-notdefault" when user does not specify
manifest group
* Expand -g option help to include example usage of manifest groups
Change Benefits:
* Allow a more intuitive and expressive manifest groups specification:
* "default" instead of "all,-notdefault"
* "default,foo" instead of "all,-notdefault,foo"
* "default,-foo" instead of "all,-notdefault,-foo"
* "foo,-default" which has no equivalent
* Default manifest groups behavior can be restored by the command
'repo init -g default'. This is significantly more intuitive than the
current equivalent command 'repo init -g all,-notdefault'.
Change-Id: I6d0673791d64a650110a917c248bcebb23b279d3
2012-11-15 00:19:00 +00:00
|
|
|
expanded_manifest_groups = manifest_groups or ['default']
|
2012-08-13 20:11:18 +00:00
|
|
|
expanded_project_groups = ['all'] + (self.groups or [])
|
2016-02-10 17:44:30 +00:00
|
|
|
if 'notdefault' not in expanded_project_groups:
|
Special handling for manifest group "default"
Change Details:
* Make "default" a special manifest group that matches any project that
does not have the special project group "notdefault"
* Use "default" instead of "all,-notdefault" when user does not specify
manifest group
* Expand -g option help to include example usage of manifest groups
Change Benefits:
* Allow a more intuitive and expressive manifest groups specification:
* "default" instead of "all,-notdefault"
* "default,foo" instead of "all,-notdefault,foo"
* "default,-foo" instead of "all,-notdefault,-foo"
* "foo,-default" which has no equivalent
* Default manifest groups behavior can be restored by the command
'repo init -g default'. This is significantly more intuitive than the
current equivalent command 'repo init -g all,-notdefault'.
Change-Id: I6d0673791d64a650110a917c248bcebb23b279d3
2012-11-15 00:19:00 +00:00
|
|
|
expanded_project_groups += ['default']
|
2012-08-13 20:11:18 +00:00
|
|
|
|
2012-04-16 17:36:08 +00:00
|
|
|
matched = False
|
2012-08-13 20:11:18 +00:00
|
|
|
for group in expanded_manifest_groups:
|
|
|
|
if group.startswith('-') and group[1:] in expanded_project_groups:
|
2012-04-16 17:36:08 +00:00
|
|
|
matched = False
|
2012-08-13 20:11:18 +00:00
|
|
|
elif group in expanded_project_groups:
|
2012-04-16 17:36:08 +00:00
|
|
|
matched = True
|
|
|
|
|
|
|
|
return matched
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
# Status Display ##
|
2014-10-05 22:40:30 +00:00
|
|
|
def UncommitedFiles(self, get_all=True):
|
|
|
|
"""Returns a list of strings, uncommitted files in the git tree.
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2014-10-05 22:40:30 +00:00
|
|
|
Args:
|
|
|
|
get_all: a boolean, if True - get information about all different
|
|
|
|
uncommitted files. If False - return as soon as any kind of
|
|
|
|
uncommitted files is detected.
|
2010-04-08 15:28:59 +00:00
|
|
|
"""
|
2014-10-05 22:40:30 +00:00
|
|
|
details = []
|
2010-04-08 15:28:59 +00:00
|
|
|
self.work_git.update_index('-q',
|
|
|
|
'--unmerged',
|
|
|
|
'--ignore-missing',
|
|
|
|
'--refresh')
|
|
|
|
if self.IsRebaseInProgress():
|
2014-10-05 22:40:30 +00:00
|
|
|
details.append("rebase in progress")
|
|
|
|
if not get_all:
|
|
|
|
return details
|
2010-04-08 15:28:59 +00:00
|
|
|
|
2014-10-05 22:40:30 +00:00
|
|
|
changes = self.work_git.DiffZ('diff-index', '--cached', HEAD).keys()
|
|
|
|
if changes:
|
|
|
|
details.extend(changes)
|
|
|
|
if not get_all:
|
|
|
|
return details
|
2010-04-08 15:28:59 +00:00
|
|
|
|
2014-10-05 22:40:30 +00:00
|
|
|
changes = self.work_git.DiffZ('diff-files').keys()
|
|
|
|
if changes:
|
|
|
|
details.extend(changes)
|
|
|
|
if not get_all:
|
|
|
|
return details
|
2010-04-08 15:28:59 +00:00
|
|
|
|
2014-10-05 22:40:30 +00:00
|
|
|
changes = self.work_git.LsOthers()
|
|
|
|
if changes:
|
|
|
|
details.extend(changes)
|
2010-04-08 15:28:59 +00:00
|
|
|
|
2014-10-05 22:40:30 +00:00
|
|
|
return details
|
|
|
|
|
|
|
|
def HasChanges(self):
|
|
|
|
"""Returns true if there are uncommitted changes.
|
|
|
|
"""
|
|
|
|
if self.UncommitedFiles(get_all=False):
|
|
|
|
return True
|
|
|
|
else:
|
|
|
|
return False
|
2010-04-08 15:28:59 +00:00
|
|
|
|
2012-02-27 19:52:22 +00:00
|
|
|
def PrintWorkTreeStatus(self, output_redir=None, quiet=False):
|
2008-10-21 14:00:00 +00:00
|
|
|
"""Prints the status of the repository to stdout.
|
2011-03-31 10:33:34 +00:00
|
|
|
|
|
|
|
Args:
|
2020-01-25 12:49:14 +00:00
|
|
|
output_redir: If specified, redirect the output to this object.
|
2012-02-27 19:52:22 +00:00
|
|
|
quiet: If True then only print the project name. Do not print
|
|
|
|
the modified files, branch name, etc.
|
2008-10-21 14:00:00 +00:00
|
|
|
"""
|
2018-09-27 17:46:58 +00:00
|
|
|
if not platform_utils.isdir(self.worktree):
|
2016-02-10 17:44:30 +00:00
|
|
|
if output_redir is None:
|
2011-03-31 10:33:34 +00:00
|
|
|
output_redir = sys.stdout
|
2012-11-02 05:59:27 +00:00
|
|
|
print(file=output_redir)
|
|
|
|
print('project %s/' % self.relpath, file=output_redir)
|
|
|
|
print(' missing (run "repo sync")', file=output_redir)
|
2008-10-21 14:00:00 +00:00
|
|
|
return
|
|
|
|
|
|
|
|
self.work_git.update_index('-q',
|
|
|
|
'--unmerged',
|
|
|
|
'--ignore-missing',
|
|
|
|
'--refresh')
|
2009-04-18 22:26:10 +00:00
|
|
|
rb = self.IsRebaseInProgress()
|
2008-10-21 14:00:00 +00:00
|
|
|
di = self.work_git.DiffZ('diff-index', '-M', '--cached', HEAD)
|
|
|
|
df = self.work_git.DiffZ('diff-files')
|
|
|
|
do = self.work_git.LsOthers()
|
2012-01-25 09:51:12 +00:00
|
|
|
if not rb and not di and not df and not do and not self.CurrentBranch:
|
2009-04-11 00:41:44 +00:00
|
|
|
return 'CLEAN'
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
out = StatusColoring(self.config)
|
2016-02-10 17:44:30 +00:00
|
|
|
if output_redir is not None:
|
2011-03-31 10:33:34 +00:00
|
|
|
out.redirect(output_redir)
|
2014-09-09 22:39:15 +00:00
|
|
|
out.project('project %-40s', self.relpath + '/ ')
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2012-02-27 19:52:22 +00:00
|
|
|
if quiet:
|
|
|
|
out.nl()
|
|
|
|
return 'DIRTY'
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
branch = self.CurrentBranch
|
|
|
|
if branch is None:
|
|
|
|
out.nobranch('(*** NO BRANCH ***)')
|
|
|
|
else:
|
|
|
|
out.branch('branch %s', branch)
|
|
|
|
out.nl()
|
|
|
|
|
2009-04-18 22:26:10 +00:00
|
|
|
if rb:
|
|
|
|
out.important('prior sync failed; rebase still in progress')
|
|
|
|
out.nl()
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
paths = list()
|
|
|
|
paths.extend(di.keys())
|
|
|
|
paths.extend(df.keys())
|
|
|
|
paths.extend(do)
|
|
|
|
|
2013-03-01 13:44:38 +00:00
|
|
|
for p in sorted(set(paths)):
|
2012-10-11 07:44:48 +00:00
|
|
|
try:
|
|
|
|
i = di[p]
|
|
|
|
except KeyError:
|
|
|
|
i = None
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2012-10-11 07:44:48 +00:00
|
|
|
try:
|
|
|
|
f = df[p]
|
|
|
|
except KeyError:
|
|
|
|
f = None
|
2010-06-17 15:55:02 +00:00
|
|
|
|
2012-10-11 07:44:48 +00:00
|
|
|
if i:
|
|
|
|
i_status = i.status.upper()
|
|
|
|
else:
|
|
|
|
i_status = '-'
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2012-10-11 07:44:48 +00:00
|
|
|
if f:
|
|
|
|
f_status = f.status.lower()
|
|
|
|
else:
|
|
|
|
f_status = '-'
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
if i and i.src_path:
|
2009-03-03 21:49:48 +00:00
|
|
|
line = ' %s%s\t%s => %s (%s%%)' % (i_status, f_status,
|
2016-02-10 17:44:30 +00:00
|
|
|
i.src_path, p, i.level)
|
2008-10-21 14:00:00 +00:00
|
|
|
else:
|
|
|
|
line = ' %s%s\t%s' % (i_status, f_status, p)
|
|
|
|
|
|
|
|
if i and not f:
|
|
|
|
out.added('%s', line)
|
|
|
|
elif (i and f) or (not i and f):
|
|
|
|
out.changed('%s', line)
|
|
|
|
elif not i and not f:
|
|
|
|
out.untracked('%s', line)
|
|
|
|
else:
|
|
|
|
out.write('%s', line)
|
|
|
|
out.nl()
|
2011-03-31 10:33:34 +00:00
|
|
|
|
2009-04-11 00:41:44 +00:00
|
|
|
return 'DIRTY'
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2012-03-28 11:49:58 +00:00
|
|
|
def PrintWorkTreeDiff(self, absolute_paths=False):
|
2008-10-21 14:00:00 +00:00
|
|
|
"""Prints the status of the repository to stdout.
|
|
|
|
"""
|
|
|
|
out = DiffColoring(self.config)
|
|
|
|
cmd = ['diff']
|
|
|
|
if out.is_on:
|
|
|
|
cmd.append('--color')
|
|
|
|
cmd.append(HEAD)
|
2012-03-28 11:49:58 +00:00
|
|
|
if absolute_paths:
|
|
|
|
cmd.append('--src-prefix=a/%s/' % self.relpath)
|
|
|
|
cmd.append('--dst-prefix=b/%s/' % self.relpath)
|
2008-10-21 14:00:00 +00:00
|
|
|
cmd.append('--')
|
2019-10-01 03:59:27 +00:00
|
|
|
try:
|
|
|
|
p = GitCommand(self,
|
|
|
|
cmd,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True)
|
|
|
|
except GitError as e:
|
|
|
|
out.nl()
|
|
|
|
out.project('project %s/' % self.relpath)
|
|
|
|
out.nl()
|
|
|
|
out.fail('%s', str(e))
|
|
|
|
out.nl()
|
|
|
|
return False
|
2008-10-21 14:00:00 +00:00
|
|
|
has_diff = False
|
|
|
|
for line in p.process.stdout:
|
2019-08-03 06:14:28 +00:00
|
|
|
if not hasattr(line, 'encode'):
|
|
|
|
line = line.decode()
|
2008-10-21 14:00:00 +00:00
|
|
|
if not has_diff:
|
|
|
|
out.nl()
|
|
|
|
out.project('project %s/' % self.relpath)
|
|
|
|
out.nl()
|
|
|
|
has_diff = True
|
2012-11-02 05:59:27 +00:00
|
|
|
print(line[:-1])
|
2019-10-01 03:59:27 +00:00
|
|
|
return p.Wait() == 0
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
# Publish / Upload ##
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
def WasPublished(self, branch, all_refs=None):
|
2008-10-21 14:00:00 +00:00
|
|
|
"""Was the branch published (uploaded) for code review?
|
|
|
|
If so, returns the SHA-1 hash of the last published
|
|
|
|
state for the branch.
|
|
|
|
"""
|
2009-04-18 03:58:02 +00:00
|
|
|
key = R_PUB + branch
|
2012-09-24 03:15:13 +00:00
|
|
|
if all_refs is None:
|
2009-04-18 03:58:02 +00:00
|
|
|
try:
|
|
|
|
return self.bare_git.rev_parse(key)
|
|
|
|
except GitError:
|
|
|
|
return None
|
|
|
|
else:
|
|
|
|
try:
|
2012-09-24 03:15:13 +00:00
|
|
|
return all_refs[key]
|
2009-04-18 03:58:02 +00:00
|
|
|
except KeyError:
|
|
|
|
return None
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
def CleanPublishedCache(self, all_refs=None):
|
2008-10-21 14:00:00 +00:00
|
|
|
"""Prunes any stale published refs.
|
|
|
|
"""
|
2012-09-24 03:15:13 +00:00
|
|
|
if all_refs is None:
|
|
|
|
all_refs = self._allrefs
|
2008-10-21 14:00:00 +00:00
|
|
|
heads = set()
|
|
|
|
canrm = {}
|
2013-03-01 13:44:38 +00:00
|
|
|
for name, ref_id in all_refs.items():
|
2008-10-21 14:00:00 +00:00
|
|
|
if name.startswith(R_HEADS):
|
|
|
|
heads.add(name)
|
|
|
|
elif name.startswith(R_PUB):
|
2012-09-24 03:15:13 +00:00
|
|
|
canrm[name] = ref_id
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2013-03-01 13:44:38 +00:00
|
|
|
for name, ref_id in canrm.items():
|
2008-10-21 14:00:00 +00:00
|
|
|
n = name[len(R_PUB):]
|
|
|
|
if R_HEADS + n not in heads:
|
2012-09-24 03:15:13 +00:00
|
|
|
self.bare_git.DeleteRef(name, ref_id)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2011-05-26 17:34:11 +00:00
|
|
|
def GetUploadableBranches(self, selected_branch=None):
|
2008-10-21 14:00:00 +00:00
|
|
|
"""List any branches which can be uploaded for review.
|
|
|
|
"""
|
|
|
|
heads = {}
|
|
|
|
pubed = {}
|
|
|
|
|
2013-03-01 13:44:38 +00:00
|
|
|
for name, ref_id in self._allrefs.items():
|
2008-10-21 14:00:00 +00:00
|
|
|
if name.startswith(R_HEADS):
|
2012-09-24 03:15:13 +00:00
|
|
|
heads[name[len(R_HEADS):]] = ref_id
|
2008-10-21 14:00:00 +00:00
|
|
|
elif name.startswith(R_PUB):
|
2012-09-24 03:15:13 +00:00
|
|
|
pubed[name[len(R_PUB):]] = ref_id
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
ready = []
|
2013-03-01 13:44:38 +00:00
|
|
|
for branch, ref_id in heads.items():
|
2012-09-24 03:15:13 +00:00
|
|
|
if branch in pubed and pubed[branch] == ref_id:
|
2008-10-21 14:00:00 +00:00
|
|
|
continue
|
2011-05-26 17:34:11 +00:00
|
|
|
if selected_branch and branch != selected_branch:
|
|
|
|
continue
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2008-11-12 01:03:13 +00:00
|
|
|
rb = self.GetUploadableBranch(branch)
|
|
|
|
if rb:
|
|
|
|
ready.append(rb)
|
2008-10-21 14:00:00 +00:00
|
|
|
return ready
|
|
|
|
|
2008-11-12 01:03:13 +00:00
|
|
|
def GetUploadableBranch(self, branch_name):
|
|
|
|
"""Get a single uploadable branch, or None.
|
|
|
|
"""
|
|
|
|
branch = self.GetBranch(branch_name)
|
|
|
|
base = branch.LocalMerge
|
|
|
|
if branch.LocalMerge:
|
|
|
|
rb = ReviewableBranch(self, branch, base)
|
|
|
|
if rb.commits:
|
|
|
|
return rb
|
|
|
|
return None
|
|
|
|
|
2010-07-15 23:52:42 +00:00
|
|
|
def UploadForReview(self, branch=None,
|
2014-07-16 11:56:40 +00:00
|
|
|
people=([], []),
|
2012-07-28 22:37:04 +00:00
|
|
|
auto_topic=False,
|
2017-08-08 18:34:53 +00:00
|
|
|
draft=False,
|
2017-08-02 14:55:03 +00:00
|
|
|
private=False,
|
2018-10-31 20:48:01 +00:00
|
|
|
notify=None,
|
2017-08-02 14:55:03 +00:00
|
|
|
wip=False,
|
2017-08-08 08:18:11 +00:00
|
|
|
dest_branch=None,
|
2017-11-13 18:48:34 +00:00
|
|
|
validate_certs=True,
|
|
|
|
push_options=None):
|
2008-10-21 14:00:00 +00:00
|
|
|
"""Uploads the named branch for code review.
|
|
|
|
"""
|
|
|
|
if branch is None:
|
|
|
|
branch = self.CurrentBranch
|
|
|
|
if branch is None:
|
|
|
|
raise GitError('not currently on a branch')
|
|
|
|
|
|
|
|
branch = self.GetBranch(branch)
|
|
|
|
if not branch.LocalMerge:
|
|
|
|
raise GitError('branch %s does not track a remote' % branch.name)
|
|
|
|
if not branch.remote.review:
|
|
|
|
raise GitError('remote %s has no review url' % branch.remote.name)
|
|
|
|
|
2013-05-06 17:36:24 +00:00
|
|
|
if dest_branch is None:
|
|
|
|
dest_branch = self.dest_branch
|
|
|
|
if dest_branch is None:
|
|
|
|
dest_branch = branch.merge
|
2008-10-21 14:00:00 +00:00
|
|
|
if not dest_branch.startswith(R_HEADS):
|
|
|
|
dest_branch = R_HEADS + dest_branch
|
|
|
|
|
2008-11-06 17:52:51 +00:00
|
|
|
if not branch.remote.projectname:
|
|
|
|
branch.remote.projectname = self.name
|
|
|
|
branch.remote.Save()
|
|
|
|
|
2017-08-08 08:18:11 +00:00
|
|
|
url = branch.remote.ReviewUrl(self.UserEmail, validate_certs)
|
2012-01-11 22:58:54 +00:00
|
|
|
if url is None:
|
|
|
|
raise UploadError('review not configured')
|
|
|
|
cmd = ['push']
|
2009-01-06 00:18:58 +00:00
|
|
|
|
2012-01-11 22:58:54 +00:00
|
|
|
if url.startswith('ssh://'):
|
2018-11-05 21:21:52 +00:00
|
|
|
cmd.append('--receive-pack=gerrit receive-pack')
|
2010-07-15 23:52:42 +00:00
|
|
|
|
2017-11-13 18:48:34 +00:00
|
|
|
for push_option in (push_options or []):
|
|
|
|
cmd.append('-o')
|
|
|
|
cmd.append(push_option)
|
|
|
|
|
2012-01-11 22:58:54 +00:00
|
|
|
cmd.append(url)
|
2009-01-06 00:18:58 +00:00
|
|
|
|
2012-01-11 22:58:54 +00:00
|
|
|
if dest_branch.startswith(R_HEADS):
|
|
|
|
dest_branch = dest_branch[len(R_HEADS):]
|
2012-07-28 22:37:04 +00:00
|
|
|
|
2017-08-08 18:34:53 +00:00
|
|
|
upload_type = 'for'
|
|
|
|
if draft:
|
|
|
|
upload_type = 'drafts'
|
|
|
|
|
|
|
|
ref_spec = '%s:refs/%s/%s' % (R_HEADS + branch.name, upload_type,
|
|
|
|
dest_branch)
|
2018-11-15 03:01:22 +00:00
|
|
|
opts = []
|
2012-01-11 22:58:54 +00:00
|
|
|
if auto_topic:
|
2018-11-15 03:01:22 +00:00
|
|
|
opts += ['topic=' + branch.name]
|
2017-08-02 14:55:03 +00:00
|
|
|
|
2018-11-15 03:01:22 +00:00
|
|
|
opts += ['r=%s' % p for p in people[0]]
|
2018-11-05 21:21:52 +00:00
|
|
|
opts += ['cc=%s' % p for p in people[1]]
|
2018-10-31 20:48:01 +00:00
|
|
|
if notify:
|
|
|
|
opts += ['notify=' + notify]
|
2018-11-05 21:21:52 +00:00
|
|
|
if private:
|
|
|
|
opts += ['private']
|
|
|
|
if wip:
|
|
|
|
opts += ['wip']
|
|
|
|
if opts:
|
|
|
|
ref_spec = ref_spec + '%' + ','.join(opts)
|
2012-01-11 22:58:54 +00:00
|
|
|
cmd.append(ref_spec)
|
|
|
|
|
2014-07-16 11:56:40 +00:00
|
|
|
if GitCommand(self, cmd, bare=True).Wait() != 0:
|
2012-01-11 22:58:54 +00:00
|
|
|
raise UploadError('Upload failed')
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
msg = "posted to %s for %s" % (branch.remote.review, dest_branch)
|
|
|
|
self.bare_git.UpdateRef(R_PUB + branch.name,
|
|
|
|
R_HEADS + branch.name,
|
2014-07-16 11:56:40 +00:00
|
|
|
message=msg)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
# Sync ##
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2013-10-16 09:02:35 +00:00
|
|
|
def _ExtractArchive(self, tarpath, path=None):
|
|
|
|
"""Extract the given tar on its current location
|
|
|
|
|
|
|
|
Args:
|
|
|
|
- tarpath: The path to the actual tar file
|
|
|
|
|
|
|
|
"""
|
|
|
|
try:
|
|
|
|
with tarfile.open(tarpath, 'r') as tar:
|
|
|
|
tar.extractall(path=path)
|
|
|
|
return True
|
|
|
|
except (IOError, tarfile.TarError) as e:
|
2015-08-24 05:39:14 +00:00
|
|
|
_error("Cannot extract archive %s: %s", tarpath, str(e))
|
2013-10-16 09:02:35 +00:00
|
|
|
return False
|
|
|
|
|
2012-03-14 22:36:59 +00:00
|
|
|
def Sync_NetworkHalf(self,
|
2016-02-10 17:44:30 +00:00
|
|
|
quiet=False,
|
|
|
|
is_new=None,
|
|
|
|
current_branch_only=False,
|
|
|
|
force_sync=False,
|
|
|
|
clone_bundle=True,
|
|
|
|
no_tags=False,
|
|
|
|
archive=False,
|
|
|
|
optimized_fetch=False,
|
2017-03-21 23:05:12 +00:00
|
|
|
prune=False,
|
2019-06-03 18:24:30 +00:00
|
|
|
submodules=False,
|
|
|
|
clone_filter=None):
|
2008-10-21 14:00:00 +00:00
|
|
|
"""Perform only the network IO portion of the sync process.
|
|
|
|
Local working directory/branch state is not affected.
|
|
|
|
"""
|
2013-10-16 09:02:35 +00:00
|
|
|
if archive and not isinstance(self, MetaProject):
|
|
|
|
if self.remote.url.startswith(('http://', 'https://')):
|
2015-08-24 05:39:14 +00:00
|
|
|
_error("%s: Cannot fetch archives from http/https remotes.", self.name)
|
2013-10-16 09:02:35 +00:00
|
|
|
return False
|
|
|
|
|
|
|
|
name = self.relpath.replace('\\', '/')
|
|
|
|
name = name.replace('/', '_')
|
|
|
|
tarpath = '%s.tar' % name
|
|
|
|
topdir = self.manifest.topdir
|
|
|
|
|
|
|
|
try:
|
|
|
|
self._FetchArchive(tarpath, cwd=topdir)
|
|
|
|
except GitError as e:
|
2015-08-24 05:39:14 +00:00
|
|
|
_error('%s', e)
|
2013-10-16 09:02:35 +00:00
|
|
|
return False
|
|
|
|
|
|
|
|
# From now on, we only need absolute tarpath
|
|
|
|
tarpath = os.path.join(topdir, tarpath)
|
|
|
|
|
|
|
|
if not self._ExtractArchive(tarpath, path=topdir):
|
|
|
|
return False
|
|
|
|
try:
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(tarpath)
|
2013-10-16 09:02:35 +00:00
|
|
|
except OSError as e:
|
2015-08-24 05:39:14 +00:00
|
|
|
_warn("Cannot remove archive %s: %s", tarpath, str(e))
|
2014-04-21 22:10:59 +00:00
|
|
|
self._CopyAndLinkFiles()
|
2013-10-16 09:02:35 +00:00
|
|
|
return True
|
2011-09-19 21:50:58 +00:00
|
|
|
if is_new is None:
|
|
|
|
is_new = not self.Exists
|
2010-10-08 08:02:09 +00:00
|
|
|
if is_new:
|
2014-11-12 18:27:45 +00:00
|
|
|
self._InitGitDir(force_sync=force_sync)
|
2012-10-24 11:44:42 +00:00
|
|
|
else:
|
|
|
|
self._UpdateHooks()
|
2008-10-21 14:00:00 +00:00
|
|
|
self._InitRemote()
|
2011-10-03 15:30:24 +00:00
|
|
|
|
|
|
|
if is_new:
|
|
|
|
alt = os.path.join(self.gitdir, 'objects/info/alternates')
|
|
|
|
try:
|
2019-11-11 10:40:22 +00:00
|
|
|
with open(alt) as fd:
|
2018-01-22 16:57:29 +00:00
|
|
|
# This works for both absolute and relative alternate directories.
|
|
|
|
alt_dir = os.path.join(self.objdir, 'objects', fd.readline().rstrip())
|
2011-10-03 15:30:24 +00:00
|
|
|
except IOError:
|
|
|
|
alt_dir = None
|
|
|
|
else:
|
|
|
|
alt_dir = None
|
|
|
|
|
2012-03-14 22:36:59 +00:00
|
|
|
if clone_bundle \
|
2016-02-10 17:44:30 +00:00
|
|
|
and alt_dir is None \
|
|
|
|
and self._ApplyCloneBundle(initial=is_new, quiet=quiet):
|
2011-10-03 15:30:24 +00:00
|
|
|
is_new = False
|
|
|
|
|
2012-05-24 16:46:50 +00:00
|
|
|
if not current_branch_only:
|
|
|
|
if self.sync_c:
|
|
|
|
current_branch_only = True
|
|
|
|
elif not self.manifest._loaded:
|
|
|
|
# Manifest cannot check defaults until it syncs.
|
|
|
|
current_branch_only = False
|
|
|
|
elif self.manifest.default.sync_c:
|
|
|
|
current_branch_only = True
|
|
|
|
|
2018-02-14 07:57:31 +00:00
|
|
|
if not no_tags:
|
|
|
|
if not self.sync_tags:
|
|
|
|
no_tags = True
|
|
|
|
|
2016-10-25 16:03:51 +00:00
|
|
|
if self.clone_depth:
|
|
|
|
depth = self.clone_depth
|
|
|
|
else:
|
|
|
|
depth = self.manifest.manifestProject.config.GetString('repo.depth')
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
need_to_fetch = not (optimized_fetch and
|
|
|
|
(ID_RE.match(self.revisionExpr) and
|
2017-06-16 14:56:09 +00:00
|
|
|
self._CheckForImmutableRevision()))
|
2016-02-10 17:44:30 +00:00
|
|
|
if (need_to_fetch and
|
|
|
|
not self._RemoteFetch(initial=is_new, quiet=quiet, alt_dir=alt_dir,
|
|
|
|
current_branch_only=current_branch_only,
|
2017-03-21 23:05:12 +00:00
|
|
|
no_tags=no_tags, prune=prune, depth=depth,
|
2019-06-03 18:24:30 +00:00
|
|
|
submodules=submodules, force_sync=force_sync,
|
|
|
|
clone_filter=clone_filter)):
|
2014-07-16 11:56:40 +00:00
|
|
|
return False
|
2008-11-04 15:37:10 +00:00
|
|
|
|
2018-10-19 10:07:05 +00:00
|
|
|
mp = self.manifest.manifestProject
|
|
|
|
dissociate = mp.config.GetBoolean('repo.dissociate')
|
|
|
|
if dissociate:
|
|
|
|
alternates_file = os.path.join(self.gitdir, 'objects/info/alternates')
|
|
|
|
if os.path.exists(alternates_file):
|
|
|
|
cmd = ['repack', '-a', '-d']
|
|
|
|
if GitCommand(self, cmd, bare=True).Wait() != 0:
|
|
|
|
return False
|
|
|
|
platform_utils.remove(alternates_file)
|
|
|
|
|
2008-11-04 15:37:10 +00:00
|
|
|
if self.worktree:
|
|
|
|
self._InitMRef()
|
|
|
|
else:
|
|
|
|
self._InitMirrorHead()
|
|
|
|
try:
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(os.path.join(self.gitdir, 'FETCH_HEAD'))
|
2008-11-04 15:37:10 +00:00
|
|
|
except OSError:
|
|
|
|
pass
|
2008-10-21 14:00:00 +00:00
|
|
|
return True
|
2008-11-03 18:32:09 +00:00
|
|
|
|
|
|
|
def PostRepoUpgrade(self):
|
|
|
|
self._InitHooks()
|
|
|
|
|
2014-04-21 22:10:59 +00:00
|
|
|
def _CopyAndLinkFiles(self):
|
2015-08-20 19:19:28 +00:00
|
|
|
if self.manifest.isGitcClient:
|
|
|
|
return
|
2012-09-24 03:15:13 +00:00
|
|
|
for copyfile in self.copyfiles:
|
|
|
|
copyfile._Copy()
|
2014-04-21 22:10:59 +00:00
|
|
|
for linkfile in self.linkfiles:
|
|
|
|
linkfile._Link()
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2014-01-09 15:21:37 +00:00
|
|
|
def GetCommitRevisionId(self):
|
|
|
|
"""Get revisionId of a commit.
|
|
|
|
|
|
|
|
Use this method instead of GetRevisionId to get the id of the commit rather
|
|
|
|
than the id of the current git object (for example, a tag)
|
|
|
|
|
|
|
|
"""
|
|
|
|
if not self.revisionExpr.startswith(R_TAGS):
|
|
|
|
return self.GetRevisionId(self._allrefs)
|
|
|
|
|
|
|
|
try:
|
|
|
|
return self.bare_git.rev_list(self.revisionExpr, '-1')[0]
|
|
|
|
except GitError:
|
2016-02-10 17:44:30 +00:00
|
|
|
raise ManifestInvalidRevisionError('revision %s in %s not found' %
|
|
|
|
(self.revisionExpr, self.name))
|
2014-01-09 15:21:37 +00:00
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
def GetRevisionId(self, all_refs=None):
|
2009-05-30 01:38:17 +00:00
|
|
|
if self.revisionId:
|
|
|
|
return self.revisionId
|
|
|
|
|
|
|
|
rem = self.GetRemote(self.remote.name)
|
|
|
|
rev = rem.ToLocal(self.revisionExpr)
|
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
if all_refs is not None and rev in all_refs:
|
|
|
|
return all_refs[rev]
|
2009-05-30 01:38:17 +00:00
|
|
|
|
|
|
|
try:
|
|
|
|
return self.bare_git.rev_parse('--verify', '%s^0' % rev)
|
|
|
|
except GitError:
|
2016-02-10 17:44:30 +00:00
|
|
|
raise ManifestInvalidRevisionError('revision %s in %s not found' %
|
|
|
|
(self.revisionExpr, self.name))
|
2009-05-30 01:38:17 +00:00
|
|
|
|
2017-03-21 23:05:12 +00:00
|
|
|
def Sync_LocalHalf(self, syncbuf, force_sync=False, submodules=False):
|
2008-10-21 14:00:00 +00:00
|
|
|
"""Perform only the local IO portion of the sync process.
|
|
|
|
Network access is not required.
|
|
|
|
"""
|
2019-11-11 10:10:03 +00:00
|
|
|
if not os.path.exists(self.gitdir):
|
|
|
|
syncbuf.fail(self,
|
|
|
|
'Cannot checkout %s due to missing network sync; Run '
|
|
|
|
'`repo sync -n %s` first.' %
|
|
|
|
(self.name, self.name))
|
|
|
|
return
|
|
|
|
|
2017-03-21 23:05:12 +00:00
|
|
|
self._InitWorkTree(force_sync=force_sync, submodules=submodules)
|
2012-09-24 03:15:13 +00:00
|
|
|
all_refs = self.bare_ref.all
|
|
|
|
self.CleanPublishedCache(all_refs)
|
|
|
|
revid = self.GetRevisionId(all_refs)
|
2011-03-08 20:14:41 +00:00
|
|
|
|
2012-10-25 03:23:11 +00:00
|
|
|
def _doff():
|
|
|
|
self._FastForward(revid)
|
2014-04-21 22:10:59 +00:00
|
|
|
self._CopyAndLinkFiles()
|
2012-10-25 03:23:11 +00:00
|
|
|
|
2017-03-21 23:05:12 +00:00
|
|
|
def _dosubmodules():
|
|
|
|
self._SyncSubmodules(quiet=True)
|
|
|
|
|
2009-04-18 03:58:02 +00:00
|
|
|
head = self.work_git.GetHead()
|
|
|
|
if head.startswith(R_HEADS):
|
|
|
|
branch = head[len(R_HEADS):]
|
|
|
|
try:
|
2012-09-24 03:15:13 +00:00
|
|
|
head = all_refs[head]
|
2009-04-18 03:58:02 +00:00
|
|
|
except KeyError:
|
|
|
|
head = None
|
|
|
|
else:
|
|
|
|
branch = None
|
2008-10-21 14:00:00 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
if branch is None or syncbuf.detach_head:
|
2008-10-21 14:00:00 +00:00
|
|
|
# Currently on a detached HEAD. The user is assumed to
|
|
|
|
# not have any local modifications worth worrying about.
|
|
|
|
#
|
2009-04-18 22:26:10 +00:00
|
|
|
if self.IsRebaseInProgress():
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
syncbuf.fail(self, _PriorSyncFailedError())
|
|
|
|
return
|
|
|
|
|
2009-04-18 03:58:02 +00:00
|
|
|
if head == revid:
|
|
|
|
# No changes; don't do anything further.
|
2012-06-07 15:11:42 +00:00
|
|
|
# Except if the head needs to be detached
|
2009-04-18 03:58:02 +00:00
|
|
|
#
|
2012-06-07 15:11:42 +00:00
|
|
|
if not syncbuf.detach_head:
|
2015-09-03 19:52:28 +00:00
|
|
|
# The copy/linkfile config may have changed.
|
|
|
|
self._CopyAndLinkFiles()
|
2012-06-07 15:11:42 +00:00
|
|
|
return
|
|
|
|
else:
|
|
|
|
lost = self._revlist(not_rev(revid), HEAD)
|
|
|
|
if lost:
|
|
|
|
syncbuf.info(self, "discarding %d commits", len(lost))
|
2009-04-18 03:58:02 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
try:
|
2009-05-30 01:38:17 +00:00
|
|
|
self._Checkout(revid, quiet=True)
|
2017-03-21 23:05:12 +00:00
|
|
|
if submodules:
|
|
|
|
self._SyncSubmodules(quiet=True)
|
2012-09-09 22:37:57 +00:00
|
|
|
except GitError as e:
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
syncbuf.fail(self, e)
|
|
|
|
return
|
2014-04-21 22:10:59 +00:00
|
|
|
self._CopyAndLinkFiles()
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
return
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-04-18 03:58:02 +00:00
|
|
|
if head == revid:
|
|
|
|
# No changes; don't do anything further.
|
|
|
|
#
|
2015-09-03 19:52:28 +00:00
|
|
|
# The copy/linkfile config may have changed.
|
|
|
|
self._CopyAndLinkFiles()
|
2009-04-18 03:58:02 +00:00
|
|
|
return
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
branch = self.GetBranch(branch)
|
|
|
|
|
2009-05-30 01:38:17 +00:00
|
|
|
if not branch.LocalMerge:
|
2008-10-21 14:00:00 +00:00
|
|
|
# The current branch has no tracking configuration.
|
2011-08-30 17:52:33 +00:00
|
|
|
# Jump off it to a detached HEAD.
|
2008-10-21 14:00:00 +00:00
|
|
|
#
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
syncbuf.info(self,
|
|
|
|
"leaving %s; does not track upstream",
|
|
|
|
branch.name)
|
2008-10-21 14:00:00 +00:00
|
|
|
try:
|
2009-05-30 01:38:17 +00:00
|
|
|
self._Checkout(revid, quiet=True)
|
2017-03-21 23:05:12 +00:00
|
|
|
if submodules:
|
|
|
|
self._SyncSubmodules(quiet=True)
|
2012-09-09 22:37:57 +00:00
|
|
|
except GitError as e:
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
syncbuf.fail(self, e)
|
|
|
|
return
|
2014-04-21 22:10:59 +00:00
|
|
|
self._CopyAndLinkFiles()
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
return
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-05-30 01:38:17 +00:00
|
|
|
upstream_gain = self._revlist(not_rev(HEAD), revid)
|
2019-09-23 21:42:23 +00:00
|
|
|
|
|
|
|
# See if we can perform a fast forward merge. This can happen if our
|
|
|
|
# branch isn't in the exact same state as we last published.
|
|
|
|
try:
|
|
|
|
self.work_git.merge_base('--is-ancestor', HEAD, revid)
|
|
|
|
# Skip the published logic.
|
|
|
|
pub = False
|
|
|
|
except GitError:
|
|
|
|
pub = self.WasPublished(branch.name, all_refs)
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
if pub:
|
2009-05-30 01:38:17 +00:00
|
|
|
not_merged = self._revlist(not_rev(revid), pub)
|
2008-10-21 14:00:00 +00:00
|
|
|
if not_merged:
|
|
|
|
if upstream_gain:
|
|
|
|
# The user has published this branch and some of those
|
|
|
|
# commits are not yet merged upstream. We do not want
|
|
|
|
# to rewrite the published commits so we punt.
|
|
|
|
#
|
2010-03-02 20:38:03 +00:00
|
|
|
syncbuf.fail(self,
|
2016-02-10 17:44:30 +00:00
|
|
|
"branch %s is published (but not merged) and is now "
|
|
|
|
"%d commits behind" % (branch.name, len(upstream_gain)))
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
return
|
2009-04-21 15:26:32 +00:00
|
|
|
elif pub == head:
|
|
|
|
# All published commits are merged, and thus we are a
|
|
|
|
# strict subset. We can fast-forward safely.
|
2008-10-30 18:03:00 +00:00
|
|
|
#
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
syncbuf.later1(self, _doff)
|
2017-03-21 23:05:12 +00:00
|
|
|
if submodules:
|
|
|
|
syncbuf.later1(self, _dosubmodules)
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
return
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-05-30 01:28:25 +00:00
|
|
|
# Examine the local commits not in the remote. Find the
|
|
|
|
# last one attributed to this user, if any.
|
|
|
|
#
|
2009-05-30 01:38:17 +00:00
|
|
|
local_changes = self._revlist(not_rev(revid), HEAD, format='%H %ce')
|
2009-05-30 01:28:25 +00:00
|
|
|
last_mine = None
|
|
|
|
cnt_mine = 0
|
|
|
|
for commit in local_changes:
|
2019-08-03 06:14:28 +00:00
|
|
|
commit_id, committer_email = commit.split(' ', 1)
|
2009-05-30 01:28:25 +00:00
|
|
|
if committer_email == self.UserEmail:
|
|
|
|
last_mine = commit_id
|
|
|
|
cnt_mine += 1
|
|
|
|
|
2009-06-03 18:09:12 +00:00
|
|
|
if not upstream_gain and cnt_mine == len(local_changes):
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
return
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
if self.IsDirty(consider_untracked=False):
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
syncbuf.fail(self, _DirtyError())
|
|
|
|
return
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-05-30 01:38:17 +00:00
|
|
|
# If the upstream switched on us, warn the user.
|
|
|
|
#
|
|
|
|
if branch.merge != self.revisionExpr:
|
|
|
|
if branch.merge and self.revisionExpr:
|
|
|
|
syncbuf.info(self,
|
|
|
|
'manifest switched %s...%s',
|
|
|
|
branch.merge,
|
|
|
|
self.revisionExpr)
|
|
|
|
elif branch.merge:
|
|
|
|
syncbuf.info(self,
|
|
|
|
'manifest no longer tracks %s',
|
|
|
|
branch.merge)
|
|
|
|
|
2009-05-30 01:28:25 +00:00
|
|
|
if cnt_mine < len(local_changes):
|
2008-10-21 14:00:00 +00:00
|
|
|
# Upstream rebased. Not everything in HEAD
|
2009-05-30 01:28:25 +00:00
|
|
|
# was created by this user.
|
2008-10-21 14:00:00 +00:00
|
|
|
#
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
syncbuf.info(self,
|
|
|
|
"discarding %d commits removed from upstream",
|
2009-05-30 01:28:25 +00:00
|
|
|
len(local_changes) - cnt_mine)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-05-30 01:38:17 +00:00
|
|
|
branch.remote = self.GetRemote(self.remote.name)
|
2012-03-20 20:45:00 +00:00
|
|
|
if not ID_RE.match(self.revisionExpr):
|
|
|
|
# in case of manifest sync the revisionExpr might be a SHA1
|
|
|
|
branch.merge = self.revisionExpr
|
2014-10-02 00:22:46 +00:00
|
|
|
if not branch.merge.startswith('refs/'):
|
|
|
|
branch.merge = R_HEADS + branch.merge
|
2008-10-21 14:00:00 +00:00
|
|
|
branch.Save()
|
|
|
|
|
2012-02-28 19:53:24 +00:00
|
|
|
if cnt_mine > 0 and self.rebase:
|
2017-03-21 23:05:12 +00:00
|
|
|
def _docopyandlink():
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
def _dorebase():
|
2014-07-16 11:56:40 +00:00
|
|
|
self._Rebase(upstream='%s^1' % last_mine, onto=revid)
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
syncbuf.later2(self, _dorebase)
|
2017-03-21 23:05:12 +00:00
|
|
|
if submodules:
|
|
|
|
syncbuf.later2(self, _dosubmodules)
|
|
|
|
syncbuf.later2(self, _docopyandlink)
|
2009-05-30 01:28:25 +00:00
|
|
|
elif local_changes:
|
2008-10-21 14:00:00 +00:00
|
|
|
try:
|
2009-05-30 01:38:17 +00:00
|
|
|
self._ResetHard(revid)
|
2017-03-21 23:05:12 +00:00
|
|
|
if submodules:
|
|
|
|
self._SyncSubmodules(quiet=True)
|
2014-04-21 22:10:59 +00:00
|
|
|
self._CopyAndLinkFiles()
|
2012-09-09 22:37:57 +00:00
|
|
|
except GitError as e:
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
syncbuf.fail(self, e)
|
|
|
|
return
|
2008-10-21 14:00:00 +00:00
|
|
|
else:
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
syncbuf.later1(self, _doff)
|
2017-03-21 23:05:12 +00:00
|
|
|
if submodules:
|
|
|
|
syncbuf.later1(self, _dosubmodules)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-03-05 18:32:38 +00:00
|
|
|
def AddCopyFile(self, src, dest, absdest):
|
2008-10-21 14:00:00 +00:00
|
|
|
# dest should already be an absolute path, but src is project relative
|
|
|
|
# make src an absolute path
|
2009-03-05 18:32:38 +00:00
|
|
|
abssrc = os.path.join(self.worktree, src)
|
|
|
|
self.copyfiles.append(_CopyFile(src, dest, abssrc, absdest))
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2014-04-21 22:10:59 +00:00
|
|
|
def AddLinkFile(self, src, dest, absdest):
|
|
|
|
# dest should already be an absolute path, but src is project relative
|
2015-05-05 07:24:54 +00:00
|
|
|
# make src relative path to dest
|
|
|
|
absdestdir = os.path.dirname(absdest)
|
|
|
|
relsrc = os.path.relpath(os.path.join(self.worktree, src), absdestdir)
|
2015-06-03 15:05:17 +00:00
|
|
|
self.linkfiles.append(_LinkFile(self.worktree, src, dest, relsrc, absdest))
|
2014-04-21 22:10:59 +00:00
|
|
|
|
2012-04-12 20:04:13 +00:00
|
|
|
def AddAnnotation(self, name, value, keep):
|
|
|
|
self.annotations.append(_Annotation(name, value, keep))
|
|
|
|
|
2008-10-23 18:58:52 +00:00
|
|
|
def DownloadPatchSet(self, change_id, patch_id):
|
|
|
|
"""Download a single patch set of a single change to FETCH_HEAD.
|
|
|
|
"""
|
|
|
|
remote = self.GetRemote(self.remote.name)
|
|
|
|
|
|
|
|
cmd = ['fetch', remote.name]
|
2016-02-10 17:44:30 +00:00
|
|
|
cmd.append('refs/changes/%2.2d/%d/%d'
|
2008-10-23 18:58:52 +00:00
|
|
|
% (change_id % 100, change_id, patch_id))
|
|
|
|
if GitCommand(self, cmd, bare=True).Wait() != 0:
|
|
|
|
return None
|
|
|
|
return DownloadedChange(self,
|
2009-05-30 01:38:17 +00:00
|
|
|
self.GetRevisionId(),
|
2008-10-23 18:58:52 +00:00
|
|
|
change_id,
|
|
|
|
patch_id,
|
|
|
|
self.bare_git.rev_parse('FETCH_HEAD'))
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
# Branch Management ##
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2019-07-30 19:14:25 +00:00
|
|
|
def StartBranch(self, name, branch_merge='', revision=None):
|
2008-10-21 14:00:00 +00:00
|
|
|
"""Create a new branch off the manifest's revision.
|
|
|
|
"""
|
2015-08-20 19:19:28 +00:00
|
|
|
if not branch_merge:
|
|
|
|
branch_merge = self.revisionExpr
|
2009-04-18 21:45:51 +00:00
|
|
|
head = self.work_git.GetHead()
|
|
|
|
if head == (R_HEADS + name):
|
|
|
|
return True
|
2009-04-10 23:21:18 +00:00
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
all_refs = self.bare_ref.all
|
2014-07-16 11:56:40 +00:00
|
|
|
if R_HEADS + name in all_refs:
|
2009-04-18 21:45:51 +00:00
|
|
|
return GitCommand(self,
|
2009-04-18 22:04:41 +00:00
|
|
|
['checkout', name, '--'],
|
2014-07-16 11:56:40 +00:00
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True).Wait() == 0
|
2009-04-18 21:45:51 +00:00
|
|
|
|
|
|
|
branch = self.GetBranch(name)
|
|
|
|
branch.remote = self.GetRemote(self.remote.name)
|
2015-08-20 19:19:28 +00:00
|
|
|
branch.merge = branch_merge
|
|
|
|
if not branch.merge.startswith('refs/') and not ID_RE.match(branch_merge):
|
|
|
|
branch.merge = R_HEADS + branch_merge
|
2019-07-30 19:14:25 +00:00
|
|
|
|
|
|
|
if revision is None:
|
|
|
|
revid = self.GetRevisionId(all_refs)
|
|
|
|
else:
|
|
|
|
revid = self.work_git.rev_parse(revision)
|
2009-04-18 21:45:51 +00:00
|
|
|
|
|
|
|
if head.startswith(R_HEADS):
|
|
|
|
try:
|
2012-09-24 03:15:13 +00:00
|
|
|
head = all_refs[head]
|
2009-04-18 21:45:51 +00:00
|
|
|
except KeyError:
|
|
|
|
head = None
|
|
|
|
if revid and head and revid == head:
|
|
|
|
ref = os.path.join(self.gitdir, R_HEADS + name)
|
|
|
|
try:
|
|
|
|
os.makedirs(os.path.dirname(ref))
|
|
|
|
except OSError:
|
|
|
|
pass
|
|
|
|
_lwrite(ref, '%s\n' % revid)
|
|
|
|
_lwrite(os.path.join(self.worktree, '.git', HEAD),
|
|
|
|
'ref: %s%s\n' % (R_HEADS, name))
|
|
|
|
branch.Save()
|
|
|
|
return True
|
|
|
|
|
|
|
|
if GitCommand(self,
|
2009-05-30 01:38:17 +00:00
|
|
|
['checkout', '-b', branch.name, revid],
|
2014-07-16 11:56:40 +00:00
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True).Wait() == 0:
|
2009-04-18 21:45:51 +00:00
|
|
|
branch.Save()
|
|
|
|
return True
|
|
|
|
return False
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-04-10 20:01:24 +00:00
|
|
|
def CheckoutBranch(self, name):
|
|
|
|
"""Checkout a local topic branch.
|
2011-04-07 19:51:04 +00:00
|
|
|
|
|
|
|
Args:
|
|
|
|
name: The name of the branch to checkout.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
True if the checkout succeeded; False if it didn't; None if the branch
|
|
|
|
didn't exist.
|
2009-04-10 20:01:24 +00:00
|
|
|
"""
|
2009-04-18 22:04:41 +00:00
|
|
|
rev = R_HEADS + name
|
|
|
|
head = self.work_git.GetHead()
|
|
|
|
if head == rev:
|
|
|
|
# Already on the branch
|
|
|
|
#
|
|
|
|
return True
|
2009-04-10 20:01:24 +00:00
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
all_refs = self.bare_ref.all
|
2009-04-10 20:01:24 +00:00
|
|
|
try:
|
2012-09-24 03:15:13 +00:00
|
|
|
revid = all_refs[rev]
|
2009-04-18 22:04:41 +00:00
|
|
|
except KeyError:
|
|
|
|
# Branch does not exist in this project
|
|
|
|
#
|
2011-04-07 19:51:04 +00:00
|
|
|
return None
|
2009-04-18 22:04:41 +00:00
|
|
|
|
|
|
|
if head.startswith(R_HEADS):
|
|
|
|
try:
|
2012-09-24 03:15:13 +00:00
|
|
|
head = all_refs[head]
|
2009-04-18 22:04:41 +00:00
|
|
|
except KeyError:
|
|
|
|
head = None
|
|
|
|
|
|
|
|
if head == revid:
|
|
|
|
# Same revision; just update HEAD to point to the new
|
|
|
|
# target branch, but otherwise take no other action.
|
|
|
|
#
|
|
|
|
_lwrite(os.path.join(self.worktree, '.git', HEAD),
|
|
|
|
'ref: %s%s\n' % (R_HEADS, name))
|
|
|
|
return True
|
2009-04-10 20:01:24 +00:00
|
|
|
|
2009-04-18 22:04:41 +00:00
|
|
|
return GitCommand(self,
|
|
|
|
['checkout', name, '--'],
|
2014-07-16 11:56:40 +00:00
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True).Wait() == 0
|
2009-04-10 20:01:24 +00:00
|
|
|
|
2008-11-03 19:24:59 +00:00
|
|
|
def AbandonBranch(self, name):
|
|
|
|
"""Destroy a local topic branch.
|
2011-04-07 18:46:59 +00:00
|
|
|
|
|
|
|
Args:
|
|
|
|
name: The name of the branch to abandon.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
True if the abandon succeeded; False if it didn't; None if the branch
|
|
|
|
didn't exist.
|
2008-11-03 19:24:59 +00:00
|
|
|
"""
|
2009-04-18 22:15:24 +00:00
|
|
|
rev = R_HEADS + name
|
2012-09-24 03:15:13 +00:00
|
|
|
all_refs = self.bare_ref.all
|
|
|
|
if rev not in all_refs:
|
2011-04-07 18:46:59 +00:00
|
|
|
# Doesn't exist
|
|
|
|
return None
|
2008-11-03 19:24:59 +00:00
|
|
|
|
2009-04-18 22:15:24 +00:00
|
|
|
head = self.work_git.GetHead()
|
|
|
|
if head == rev:
|
|
|
|
# We can't destroy the branch while we are sitting
|
|
|
|
# on it. Switch to a detached HEAD.
|
|
|
|
#
|
2012-09-24 03:15:13 +00:00
|
|
|
head = all_refs[head]
|
2008-11-03 19:24:59 +00:00
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
revid = self.GetRevisionId(all_refs)
|
2009-05-30 01:38:17 +00:00
|
|
|
if head == revid:
|
2009-04-18 22:15:24 +00:00
|
|
|
_lwrite(os.path.join(self.worktree, '.git', HEAD),
|
|
|
|
'%s\n' % revid)
|
|
|
|
else:
|
2009-05-30 01:38:17 +00:00
|
|
|
self._Checkout(revid, quiet=True)
|
2009-04-18 22:15:24 +00:00
|
|
|
|
|
|
|
return GitCommand(self,
|
|
|
|
['branch', '-D', name],
|
2014-07-16 11:56:40 +00:00
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True).Wait() == 0
|
2008-11-03 19:24:59 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def PruneHeads(self):
|
|
|
|
"""Prune any topic branches already merged into upstream.
|
|
|
|
"""
|
|
|
|
cb = self.CurrentBranch
|
|
|
|
kill = []
|
2009-03-02 20:30:50 +00:00
|
|
|
left = self._allrefs
|
|
|
|
for name in left.keys():
|
2008-10-21 14:00:00 +00:00
|
|
|
if name.startswith(R_HEADS):
|
|
|
|
name = name[len(R_HEADS):]
|
|
|
|
if cb is None or name != cb:
|
|
|
|
kill.append(name)
|
|
|
|
|
2009-05-30 01:38:17 +00:00
|
|
|
rev = self.GetRevisionId(left)
|
2008-10-21 14:00:00 +00:00
|
|
|
if cb is not None \
|
|
|
|
and not self._revlist(HEAD + '...' + rev) \
|
2014-07-16 11:56:40 +00:00
|
|
|
and not self.IsDirty(consider_untracked=False):
|
2008-10-21 14:00:00 +00:00
|
|
|
self.work_git.DetachHead(HEAD)
|
|
|
|
kill.append(cb)
|
|
|
|
|
|
|
|
if kill:
|
2009-04-18 01:43:33 +00:00
|
|
|
old = self.bare_git.GetHead()
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
try:
|
|
|
|
self.bare_git.DetachHead(rev)
|
|
|
|
|
|
|
|
b = ['branch', '-d']
|
|
|
|
b.extend(kill)
|
|
|
|
b = GitCommand(self, b, bare=True,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True)
|
|
|
|
b.Wait()
|
|
|
|
finally:
|
2015-12-15 21:40:05 +00:00
|
|
|
if ID_RE.match(old):
|
|
|
|
self.bare_git.DetachHead(old)
|
|
|
|
else:
|
|
|
|
self.bare_git.SetHead(old)
|
2009-03-02 20:30:50 +00:00
|
|
|
left = self._allrefs
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-03-02 20:30:50 +00:00
|
|
|
for branch in kill:
|
|
|
|
if (R_HEADS + branch) not in left:
|
|
|
|
self.CleanPublishedCache()
|
|
|
|
break
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
if cb and cb not in kill:
|
|
|
|
kill.append(cb)
|
2009-03-02 20:38:13 +00:00
|
|
|
kill.sort()
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
kept = []
|
|
|
|
for branch in kill:
|
2014-07-16 11:56:40 +00:00
|
|
|
if R_HEADS + branch in left:
|
2008-10-21 14:00:00 +00:00
|
|
|
branch = self.GetBranch(branch)
|
|
|
|
base = branch.LocalMerge
|
|
|
|
if not base:
|
|
|
|
base = rev
|
|
|
|
kept.append(ReviewableBranch(self, branch, base))
|
|
|
|
return kept
|
|
|
|
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
# Submodule Management ##
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
|
|
|
|
def GetRegisteredSubprojects(self):
|
|
|
|
result = []
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
def rec(subprojects):
|
|
|
|
if not subprojects:
|
|
|
|
return
|
|
|
|
result.extend(subprojects)
|
|
|
|
for p in subprojects:
|
|
|
|
rec(p.subprojects)
|
|
|
|
rec(self.subprojects)
|
|
|
|
return result
|
|
|
|
|
|
|
|
def _GetSubmodules(self):
|
|
|
|
# Unfortunately we cannot call `git submodule status --recursive` here
|
|
|
|
# because the working tree might not exist yet, and it cannot be used
|
|
|
|
# without a working tree in its current implementation.
|
|
|
|
|
|
|
|
def get_submodules(gitdir, rev):
|
|
|
|
# Parse .gitmodules for submodule sub_paths and sub_urls
|
|
|
|
sub_paths, sub_urls = parse_gitmodules(gitdir, rev)
|
|
|
|
if not sub_paths:
|
|
|
|
return []
|
|
|
|
# Run `git ls-tree` to read SHAs of submodule object, which happen to be
|
|
|
|
# revision of submodule repository
|
|
|
|
sub_revs = git_ls_tree(gitdir, rev, sub_paths)
|
|
|
|
submodules = []
|
|
|
|
for sub_path, sub_url in zip(sub_paths, sub_urls):
|
|
|
|
try:
|
|
|
|
sub_rev = sub_revs[sub_path]
|
|
|
|
except KeyError:
|
|
|
|
# Ignore non-exist submodules
|
|
|
|
continue
|
|
|
|
submodules.append((sub_rev, sub_path, sub_url))
|
|
|
|
return submodules
|
|
|
|
|
2019-03-11 12:53:38 +00:00
|
|
|
re_path = re.compile(r'^submodule\.(.+)\.path=(.*)$')
|
|
|
|
re_url = re.compile(r'^submodule\.(.+)\.url=(.*)$')
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
def parse_gitmodules(gitdir, rev):
|
|
|
|
cmd = ['cat-file', 'blob', '%s:.gitmodules' % rev]
|
|
|
|
try:
|
2014-07-16 11:56:40 +00:00
|
|
|
p = GitCommand(None, cmd, capture_stdout=True, capture_stderr=True,
|
|
|
|
bare=True, gitdir=gitdir)
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
except GitError:
|
|
|
|
return [], []
|
|
|
|
if p.Wait() != 0:
|
|
|
|
return [], []
|
|
|
|
|
|
|
|
gitmodules_lines = []
|
|
|
|
fd, temp_gitmodules_path = tempfile.mkstemp()
|
|
|
|
try:
|
2020-02-11 08:35:24 +00:00
|
|
|
os.write(fd, p.stdout.encode('utf-8'))
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
os.close(fd)
|
|
|
|
cmd = ['config', '--file', temp_gitmodules_path, '--list']
|
2014-07-16 11:56:40 +00:00
|
|
|
p = GitCommand(None, cmd, capture_stdout=True, capture_stderr=True,
|
|
|
|
bare=True, gitdir=gitdir)
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
if p.Wait() != 0:
|
|
|
|
return [], []
|
|
|
|
gitmodules_lines = p.stdout.split('\n')
|
|
|
|
except GitError:
|
|
|
|
return [], []
|
|
|
|
finally:
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(temp_gitmodules_path)
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
|
|
|
|
names = set()
|
|
|
|
paths = {}
|
|
|
|
urls = {}
|
|
|
|
for line in gitmodules_lines:
|
|
|
|
if not line:
|
|
|
|
continue
|
|
|
|
m = re_path.match(line)
|
|
|
|
if m:
|
|
|
|
names.add(m.group(1))
|
|
|
|
paths[m.group(1)] = m.group(2)
|
|
|
|
continue
|
|
|
|
m = re_url.match(line)
|
|
|
|
if m:
|
|
|
|
names.add(m.group(1))
|
|
|
|
urls[m.group(1)] = m.group(2)
|
|
|
|
continue
|
|
|
|
names = sorted(names)
|
|
|
|
return ([paths.get(name, '') for name in names],
|
|
|
|
[urls.get(name, '') for name in names])
|
|
|
|
|
|
|
|
def git_ls_tree(gitdir, rev, paths):
|
|
|
|
cmd = ['ls-tree', rev, '--']
|
|
|
|
cmd.extend(paths)
|
|
|
|
try:
|
2014-07-16 11:56:40 +00:00
|
|
|
p = GitCommand(None, cmd, capture_stdout=True, capture_stderr=True,
|
|
|
|
bare=True, gitdir=gitdir)
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
except GitError:
|
|
|
|
return []
|
|
|
|
if p.Wait() != 0:
|
|
|
|
return []
|
|
|
|
objects = {}
|
|
|
|
for line in p.stdout.split('\n'):
|
|
|
|
if not line.strip():
|
|
|
|
continue
|
|
|
|
object_rev, object_path = line.split()[2:4]
|
|
|
|
objects[object_path] = object_rev
|
|
|
|
return objects
|
|
|
|
|
|
|
|
try:
|
|
|
|
rev = self.GetRevisionId()
|
|
|
|
except GitError:
|
|
|
|
return []
|
|
|
|
return get_submodules(self.gitdir, rev)
|
|
|
|
|
|
|
|
def GetDerivedSubprojects(self):
|
|
|
|
result = []
|
|
|
|
if not self.Exists:
|
|
|
|
# If git repo does not exist yet, querying its submodules will
|
|
|
|
# mess up its states; so return here.
|
|
|
|
return result
|
|
|
|
for rev, path, url in self._GetSubmodules():
|
|
|
|
name = self.manifest.GetSubprojectName(self, path)
|
2013-10-12 00:03:19 +00:00
|
|
|
relpath, worktree, gitdir, objdir = \
|
|
|
|
self.manifest.GetSubprojectPaths(self, name, path)
|
|
|
|
project = self.manifest.paths.get(relpath)
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
if project:
|
|
|
|
result.extend(project.GetDerivedSubprojects())
|
|
|
|
continue
|
2013-10-12 00:03:19 +00:00
|
|
|
|
2017-12-08 01:54:58 +00:00
|
|
|
if url.startswith('..'):
|
|
|
|
url = urllib.parse.urljoin("%s/" % self.remote.url, url)
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
remote = RemoteSpec(self.remote.name,
|
2014-07-16 11:56:40 +00:00
|
|
|
url=url,
|
2016-08-10 22:00:00 +00:00
|
|
|
pushUrl=self.remote.pushUrl,
|
2014-07-16 11:56:40 +00:00
|
|
|
review=self.remote.review,
|
|
|
|
revision=self.remote.revision)
|
|
|
|
subproject = Project(manifest=self.manifest,
|
|
|
|
name=name,
|
|
|
|
remote=remote,
|
|
|
|
gitdir=gitdir,
|
|
|
|
objdir=objdir,
|
|
|
|
worktree=worktree,
|
|
|
|
relpath=relpath,
|
2016-06-24 12:34:08 +00:00
|
|
|
revisionExpr=rev,
|
2014-07-16 11:56:40 +00:00
|
|
|
revisionId=rev,
|
|
|
|
rebase=self.rebase,
|
|
|
|
groups=self.groups,
|
|
|
|
sync_c=self.sync_c,
|
|
|
|
sync_s=self.sync_s,
|
2018-02-14 07:57:31 +00:00
|
|
|
sync_tags=self.sync_tags,
|
2014-07-16 11:56:40 +00:00
|
|
|
parent=self,
|
|
|
|
is_derived=True)
|
Represent git-submodule as nested projects, take 2
(Previous submission of this change broke Android buildbot due to
incorrect regular expression for parsing git-config output. During
investigation, we also found that Android, which pulls Chromium, has a
workaround for Chromium's submodules; its manifest includes Chromium's
submodules. This new change, in addition to fixing the regex, also
take this type of workarounds into consideration; it adds a new
attribute that makes repo not fetch submodules unless submodules have a
project element defined in the manifest, or this attribute is
overridden by a parent project element or by the default element.)
We need a representation of git-submodule in repo; otherwise repo will
not sync submodules, and leave workspace in a broken state. Of course
this will not be a problem if all projects are owned by the owner of the
manifest file, who may simply choose not to use git-submodule in all
projects. However, this is not possible in practice because manifest
file owner is unlikely to own all upstream projects.
As git submodules are simply git repositories, it is natural to treat
them as plain repo projects that live inside a repo project. That is,
we could use recursively declared projects to denote the is-submodule
relation of git repositories.
The behavior of repo remains the same to projects that do not have a
sub-project within. As for parent projects, repo fetches them and their
sub-projects as normal projects, and then checks out subprojects at the
commit specified in parent's commit object. The sub-project is fetched
at a path relative to parent project's working directory; so the path
specified in manifest file should match that of .gitmodules file.
If a submodule is not registered in repo manifest, repo will derive its
properties from itself and its parent project, which might not always be
correct. In such cases, the subproject is called a derived subproject.
To a user, a sub-project is merely a git-submodule; so all tips of
working with a git-submodule apply here, too. For example, you should
not run `repo sync` in a parent repository if its submodule is dirty.
Change-Id: I4b8344c1b9ccad2f58ad304573133e5d52e1faef
2012-01-11 03:28:42 +00:00
|
|
|
result.append(subproject)
|
|
|
|
result.extend(subproject.GetDerivedSubprojects())
|
|
|
|
return result
|
|
|
|
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
# Direct Git Commands ##
|
2017-06-16 14:56:09 +00:00
|
|
|
def _CheckForImmutableRevision(self):
|
2014-01-17 02:32:33 +00:00
|
|
|
try:
|
|
|
|
# if revision (sha or tag) is not present then following function
|
|
|
|
# throws an error.
|
|
|
|
self.bare_git.rev_parse('--verify', '%s^0' % self.revisionExpr)
|
|
|
|
return True
|
|
|
|
except GitError:
|
|
|
|
# There is no such persistent revision. We have to fetch it.
|
|
|
|
return False
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2013-10-16 09:02:35 +00:00
|
|
|
def _FetchArchive(self, tarpath, cwd=None):
|
|
|
|
cmd = ['archive', '-v', '-o', tarpath]
|
|
|
|
cmd.append('--remote=%s' % self.remote.url)
|
|
|
|
cmd.append('--prefix=%s/' % self.relpath)
|
|
|
|
cmd.append(self.revisionExpr)
|
|
|
|
|
|
|
|
command = GitCommand(self, cmd, cwd=cwd,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True)
|
|
|
|
|
|
|
|
if command.Wait() != 0:
|
|
|
|
raise GitError('git archive %s: %s' % (self.name, command.stderr))
|
|
|
|
|
2011-08-26 00:21:47 +00:00
|
|
|
def _RemoteFetch(self, name=None,
|
|
|
|
current_branch_only=False,
|
2010-10-29 19:05:43 +00:00
|
|
|
initial=False,
|
2011-10-03 15:30:24 +00:00
|
|
|
quiet=False,
|
2012-10-29 17:18:34 +00:00
|
|
|
alt_dir=None,
|
2015-10-14 01:50:15 +00:00
|
|
|
no_tags=False,
|
2016-10-25 16:03:51 +00:00
|
|
|
prune=False,
|
2017-03-21 23:05:12 +00:00
|
|
|
depth=None,
|
2019-03-19 01:27:54 +00:00
|
|
|
submodules=False,
|
2019-06-03 18:24:30 +00:00
|
|
|
force_sync=False,
|
|
|
|
clone_filter=None):
|
2011-08-26 00:21:47 +00:00
|
|
|
|
|
|
|
is_sha1 = False
|
|
|
|
tag_name = None
|
2014-04-15 01:28:56 +00:00
|
|
|
# The depth should not be used when fetching to a mirror because
|
|
|
|
# it will result in a shallow repository that cannot be cloned or
|
|
|
|
# fetched from.
|
2016-10-25 16:03:51 +00:00
|
|
|
# The repo project should also never be synced with partial depth.
|
|
|
|
if self.manifest.IsMirror or self.relpath == '.repo/repo':
|
|
|
|
depth = None
|
2011-08-26 00:21:47 +00:00
|
|
|
|
2014-01-29 20:48:54 +00:00
|
|
|
if depth:
|
|
|
|
current_branch_only = True
|
|
|
|
|
2014-09-19 18:13:04 +00:00
|
|
|
if ID_RE.match(self.revisionExpr) is not None:
|
|
|
|
is_sha1 = True
|
|
|
|
|
2011-08-26 00:21:47 +00:00
|
|
|
if current_branch_only:
|
2014-09-19 18:13:04 +00:00
|
|
|
if self.revisionExpr.startswith(R_TAGS):
|
2011-08-26 00:21:47 +00:00
|
|
|
# this is a tag and its sha1 value should never change
|
|
|
|
tag_name = self.revisionExpr[len(R_TAGS):]
|
|
|
|
|
|
|
|
if is_sha1 or tag_name is not None:
|
2017-06-16 14:56:09 +00:00
|
|
|
if self._CheckForImmutableRevision():
|
2019-04-15 09:17:08 +00:00
|
|
|
if not quiet:
|
|
|
|
print('Skipped fetching project %s (already have persistent ref)'
|
|
|
|
% self.name)
|
2011-08-26 00:21:47 +00:00
|
|
|
return True
|
2014-11-26 00:19:29 +00:00
|
|
|
if is_sha1 and not depth:
|
|
|
|
# When syncing a specific commit and --depth is not set:
|
|
|
|
# * if upstream is explicitly specified and is not a sha1, fetch only
|
|
|
|
# upstream as users expect only upstream to be fetch.
|
|
|
|
# Note: The commit might not be in upstream in which case the sync
|
|
|
|
# will fail.
|
|
|
|
# * otherwise, fetch all branches to make sure we end up with the
|
|
|
|
# specific commit.
|
2016-06-28 10:27:23 +00:00
|
|
|
if self.upstream:
|
|
|
|
current_branch_only = not ID_RE.match(self.upstream)
|
|
|
|
else:
|
|
|
|
current_branch_only = False
|
2011-08-26 00:21:47 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
if not name:
|
|
|
|
name = self.remote.name
|
2009-04-11 01:53:46 +00:00
|
|
|
|
|
|
|
ssh_proxy = False
|
2011-09-19 21:50:58 +00:00
|
|
|
remote = self.GetRemote(name)
|
|
|
|
if remote.PreConnectFetch():
|
2009-04-11 01:53:46 +00:00
|
|
|
ssh_proxy = True
|
|
|
|
|
2010-10-08 08:02:09 +00:00
|
|
|
if initial:
|
2011-10-03 15:30:24 +00:00
|
|
|
if alt_dir and 'objects' == os.path.basename(alt_dir):
|
|
|
|
ref_dir = os.path.dirname(alt_dir)
|
2010-10-08 08:02:09 +00:00
|
|
|
packed_refs = os.path.join(self.gitdir, 'packed-refs')
|
|
|
|
remote = self.GetRemote(name)
|
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
all_refs = self.bare_ref.all
|
|
|
|
ids = set(all_refs.values())
|
2010-10-08 08:02:09 +00:00
|
|
|
tmp = set()
|
|
|
|
|
2013-03-01 13:44:38 +00:00
|
|
|
for r, ref_id in GitRefs(ref_dir).all.items():
|
2012-09-24 03:15:13 +00:00
|
|
|
if r not in all_refs:
|
2010-10-08 08:02:09 +00:00
|
|
|
if r.startswith(R_TAGS) or remote.WritesTo(r):
|
2012-09-24 03:15:13 +00:00
|
|
|
all_refs[r] = ref_id
|
|
|
|
ids.add(ref_id)
|
2010-10-08 08:02:09 +00:00
|
|
|
continue
|
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
if ref_id in ids:
|
2010-10-08 08:02:09 +00:00
|
|
|
continue
|
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
r = 'refs/_alt/%s' % ref_id
|
|
|
|
all_refs[r] = ref_id
|
|
|
|
ids.add(ref_id)
|
2010-10-08 08:02:09 +00:00
|
|
|
tmp.add(r)
|
|
|
|
|
2017-04-12 11:51:47 +00:00
|
|
|
tmp_packed_lines = []
|
|
|
|
old_packed_lines = []
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2013-03-01 13:44:38 +00:00
|
|
|
for r in sorted(all_refs):
|
2012-09-24 03:15:13 +00:00
|
|
|
line = '%s %s\n' % (all_refs[r], r)
|
2017-04-12 11:51:47 +00:00
|
|
|
tmp_packed_lines.append(line)
|
2010-10-08 08:02:09 +00:00
|
|
|
if r not in tmp:
|
2017-04-12 11:51:47 +00:00
|
|
|
old_packed_lines.append(line)
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2017-04-12 11:51:47 +00:00
|
|
|
tmp_packed = ''.join(tmp_packed_lines)
|
|
|
|
old_packed = ''.join(old_packed_lines)
|
2010-10-08 08:02:09 +00:00
|
|
|
_lwrite(packed_refs, tmp_packed)
|
|
|
|
else:
|
2011-10-03 15:30:24 +00:00
|
|
|
alt_dir = None
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2008-11-04 15:37:10 +00:00
|
|
|
cmd = ['fetch']
|
2011-05-04 22:01:04 +00:00
|
|
|
|
2019-06-03 18:24:30 +00:00
|
|
|
if clone_filter:
|
|
|
|
git_require((2, 19, 0), fail=True, msg='partial clones')
|
|
|
|
cmd.append('--filter=%s' % clone_filter)
|
|
|
|
self.config.SetString('extensions.partialclone', self.remote.name)
|
|
|
|
|
2015-01-21 19:12:46 +00:00
|
|
|
if depth:
|
2011-05-04 22:01:04 +00:00
|
|
|
cmd.append('--depth=%s' % depth)
|
2015-08-03 20:11:53 +00:00
|
|
|
else:
|
|
|
|
# If this repo has shallow objects, then we don't know which refs have
|
|
|
|
# shallow objects or not. Tell git to unshallow all fetched refs. Don't
|
|
|
|
# do this with projects that don't have shallow objects, since it is less
|
|
|
|
# efficient.
|
|
|
|
if os.path.exists(os.path.join(self.gitdir, 'shallow')):
|
|
|
|
cmd.append('--depth=2147483647')
|
2011-05-04 22:01:04 +00:00
|
|
|
|
2010-10-29 19:05:43 +00:00
|
|
|
if quiet:
|
|
|
|
cmd.append('--quiet')
|
2008-11-04 15:37:10 +00:00
|
|
|
if not self.worktree:
|
|
|
|
cmd.append('--update-head-ok')
|
2011-10-03 15:30:24 +00:00
|
|
|
cmd.append(name)
|
2011-08-26 00:21:47 +00:00
|
|
|
|
2019-03-19 01:27:54 +00:00
|
|
|
if force_sync:
|
|
|
|
cmd.append('--force')
|
|
|
|
|
2015-10-14 01:50:15 +00:00
|
|
|
if prune:
|
|
|
|
cmd.append('--prune')
|
|
|
|
|
2017-03-21 23:05:12 +00:00
|
|
|
if submodules:
|
|
|
|
cmd.append('--recurse-submodules=on-demand')
|
|
|
|
|
2019-11-25 04:37:55 +00:00
|
|
|
spec = []
|
2012-09-29 03:21:57 +00:00
|
|
|
if not current_branch_only:
|
2011-08-26 00:21:47 +00:00
|
|
|
# Fetch whole repo
|
2014-05-10 00:13:44 +00:00
|
|
|
spec.append(str((u'+refs/heads/*:') + remote.ToLocal('refs/heads/*')))
|
2011-08-26 00:21:47 +00:00
|
|
|
elif tag_name is not None:
|
2014-05-10 00:13:44 +00:00
|
|
|
spec.append('tag')
|
|
|
|
spec.append(tag_name)
|
2014-09-30 19:34:52 +00:00
|
|
|
|
2020-02-04 12:20:57 +00:00
|
|
|
if self.manifest.IsMirror and not current_branch_only:
|
|
|
|
branch = None
|
|
|
|
else:
|
|
|
|
branch = self.revisionExpr
|
2019-11-25 04:37:55 +00:00
|
|
|
if (not self.manifest.IsMirror and is_sha1 and depth
|
|
|
|
and git_require((1, 8, 3))):
|
|
|
|
# Shallow checkout of a specific commit, fetch from that commit and not
|
|
|
|
# the heads only as the commit might be deeper in the history.
|
|
|
|
spec.append(branch)
|
|
|
|
else:
|
|
|
|
if is_sha1:
|
|
|
|
branch = self.upstream
|
|
|
|
if branch is not None and branch.strip():
|
|
|
|
if not branch.startswith('refs/'):
|
|
|
|
branch = R_HEADS + branch
|
|
|
|
spec.append(str((u'+%s:' % branch) + remote.ToLocal(branch)))
|
|
|
|
|
|
|
|
# If mirroring repo and we cannot deduce the tag or branch to fetch, fetch
|
|
|
|
# whole repo.
|
|
|
|
if self.manifest.IsMirror and not spec:
|
|
|
|
spec.append(str((u'+refs/heads/*:') + remote.ToLocal('refs/heads/*')))
|
|
|
|
|
|
|
|
# If using depth then we should not get all the tags since they may
|
|
|
|
# be outside of the depth.
|
|
|
|
if no_tags or depth:
|
|
|
|
cmd.append('--no-tags')
|
|
|
|
else:
|
|
|
|
cmd.append('--tags')
|
|
|
|
spec.append(str((u'+refs/tags/*:') + remote.ToLocal('refs/tags/*')))
|
|
|
|
|
2014-05-10 00:13:44 +00:00
|
|
|
cmd.extend(spec)
|
|
|
|
|
2011-10-03 15:30:24 +00:00
|
|
|
ok = False
|
2012-09-24 03:15:13 +00:00
|
|
|
for _i in range(2):
|
2015-03-17 03:49:10 +00:00
|
|
|
gitcmd = GitCommand(self, cmd, bare=True, ssh_proxy=ssh_proxy)
|
2015-01-30 05:58:12 +00:00
|
|
|
ret = gitcmd.Wait()
|
2012-09-29 03:21:57 +00:00
|
|
|
if ret == 0:
|
2011-10-03 15:30:24 +00:00
|
|
|
ok = True
|
|
|
|
break
|
2015-01-30 05:58:12 +00:00
|
|
|
# If needed, run the 'git remote prune' the first time through the loop
|
|
|
|
elif (not _i and
|
|
|
|
"error:" in gitcmd.stderr and
|
|
|
|
"git remote prune" in gitcmd.stderr):
|
|
|
|
prunecmd = GitCommand(self, ['remote', 'prune', name], bare=True,
|
2015-03-17 03:49:10 +00:00
|
|
|
ssh_proxy=ssh_proxy)
|
2015-02-25 22:27:02 +00:00
|
|
|
ret = prunecmd.Wait()
|
|
|
|
if ret:
|
2015-01-30 05:58:12 +00:00
|
|
|
break
|
|
|
|
continue
|
2012-09-29 03:21:57 +00:00
|
|
|
elif current_branch_only and is_sha1 and ret == 128:
|
2016-02-10 17:44:30 +00:00
|
|
|
# Exit code 128 means "couldn't find the ref you asked for"; if we're
|
|
|
|
# in sha1 mode, we just tried sync'ing from the upstream field; it
|
|
|
|
# doesn't exist, thus abort the optimization attempt and do a full sync.
|
2012-09-29 03:21:57 +00:00
|
|
|
break
|
2015-05-13 07:10:02 +00:00
|
|
|
elif ret < 0:
|
|
|
|
# Git died with a signal, exit immediately
|
|
|
|
break
|
2011-10-03 15:30:24 +00:00
|
|
|
time.sleep(random.randint(30, 45))
|
2010-10-08 08:02:09 +00:00
|
|
|
|
|
|
|
if initial:
|
2011-10-03 15:30:24 +00:00
|
|
|
if alt_dir:
|
2010-10-08 08:02:09 +00:00
|
|
|
if old_packed != '':
|
|
|
|
_lwrite(packed_refs, old_packed)
|
|
|
|
else:
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(packed_refs)
|
2010-10-08 08:02:09 +00:00
|
|
|
self.bare_git.pack_refs('--all', '--prune')
|
2012-09-29 03:21:57 +00:00
|
|
|
|
2016-10-25 16:03:51 +00:00
|
|
|
if is_sha1 and current_branch_only:
|
2012-09-29 03:21:57 +00:00
|
|
|
# We just synced the upstream given branch; verify we
|
|
|
|
# got what we wanted, else trigger a second run of all
|
|
|
|
# refs.
|
2017-06-16 14:56:09 +00:00
|
|
|
if not self._CheckForImmutableRevision():
|
2016-10-25 16:03:51 +00:00
|
|
|
if current_branch_only and depth:
|
|
|
|
# Sync the current branch only with depth set to None
|
2016-02-10 17:44:30 +00:00
|
|
|
return self._RemoteFetch(name=name,
|
|
|
|
current_branch_only=current_branch_only,
|
2016-10-25 16:03:51 +00:00
|
|
|
initial=False, quiet=quiet, alt_dir=alt_dir,
|
2019-06-03 18:24:30 +00:00
|
|
|
depth=None, clone_filter=clone_filter)
|
2016-10-25 16:03:51 +00:00
|
|
|
else:
|
|
|
|
# Avoid infinite recursion: sync all branches with depth set to None
|
|
|
|
return self._RemoteFetch(name=name, current_branch_only=False,
|
|
|
|
initial=False, quiet=quiet, alt_dir=alt_dir,
|
2019-06-03 18:24:30 +00:00
|
|
|
depth=None, clone_filter=clone_filter)
|
2012-09-29 03:21:57 +00:00
|
|
|
|
2011-10-03 15:30:24 +00:00
|
|
|
return ok
|
|
|
|
|
|
|
|
def _ApplyCloneBundle(self, initial=False, quiet=False):
|
2016-02-10 17:44:30 +00:00
|
|
|
if initial and \
|
|
|
|
(self.manifest.manifestProject.config.GetString('repo.depth') or
|
|
|
|
self.clone_depth):
|
2011-10-03 15:30:24 +00:00
|
|
|
return False
|
|
|
|
|
|
|
|
remote = self.GetRemote(self.remote.name)
|
|
|
|
bundle_url = remote.url + '/clone.bundle'
|
|
|
|
bundle_url = GitConfig.ForUser().UrlInsteadOf(bundle_url)
|
2016-02-10 17:44:30 +00:00
|
|
|
if GetSchemeFromUrl(bundle_url) not in ('http', 'https',
|
|
|
|
'persistent-http',
|
|
|
|
'persistent-https'):
|
2011-10-03 15:30:24 +00:00
|
|
|
return False
|
|
|
|
|
|
|
|
bundle_dst = os.path.join(self.gitdir, 'clone.bundle')
|
|
|
|
bundle_tmp = os.path.join(self.gitdir, 'clone.bundle.tmp')
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2011-10-03 15:30:24 +00:00
|
|
|
exist_dst = os.path.exists(bundle_dst)
|
|
|
|
exist_tmp = os.path.exists(bundle_tmp)
|
|
|
|
|
|
|
|
if not initial and not exist_dst and not exist_tmp:
|
|
|
|
return False
|
|
|
|
|
|
|
|
if not exist_dst:
|
|
|
|
exist_dst = self._FetchBundle(bundle_url, bundle_tmp, bundle_dst, quiet)
|
|
|
|
if not exist_dst:
|
|
|
|
return False
|
|
|
|
|
|
|
|
cmd = ['fetch']
|
|
|
|
if quiet:
|
|
|
|
cmd.append('--quiet')
|
|
|
|
if not self.worktree:
|
|
|
|
cmd.append('--update-head-ok')
|
|
|
|
cmd.append(bundle_dst)
|
|
|
|
for f in remote.fetch:
|
|
|
|
cmd.append(str(f))
|
2018-12-10 19:33:16 +00:00
|
|
|
cmd.append('+refs/tags/*:refs/tags/*')
|
2011-10-03 15:30:24 +00:00
|
|
|
|
|
|
|
ok = GitCommand(self, cmd, bare=True).Wait() == 0
|
2011-09-19 21:50:58 +00:00
|
|
|
if os.path.exists(bundle_dst):
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(bundle_dst)
|
2011-09-19 21:50:58 +00:00
|
|
|
if os.path.exists(bundle_tmp):
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(bundle_tmp)
|
2010-10-08 08:02:09 +00:00
|
|
|
return ok
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2011-10-03 15:30:24 +00:00
|
|
|
def _FetchBundle(self, srcUrl, tmpPath, dstPath, quiet):
|
2012-08-02 21:57:37 +00:00
|
|
|
if os.path.exists(dstPath):
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(dstPath)
|
2011-10-11 19:00:38 +00:00
|
|
|
|
2012-08-30 16:39:36 +00:00
|
|
|
cmd = ['curl', '--fail', '--output', tmpPath, '--netrc', '--location']
|
2012-08-02 21:57:37 +00:00
|
|
|
if quiet:
|
|
|
|
cmd += ['--silent']
|
|
|
|
if os.path.exists(tmpPath):
|
|
|
|
size = os.stat(tmpPath).st_size
|
|
|
|
if size >= 1024:
|
|
|
|
cmd += ['--continue-at', '%d' % (size,)]
|
|
|
|
else:
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(tmpPath)
|
2019-06-25 23:09:43 +00:00
|
|
|
with GetUrlCookieFile(srcUrl, quiet) as (cookiefile, proxy):
|
2015-01-02 19:12:54 +00:00
|
|
|
if cookiefile:
|
2015-01-02 19:39:04 +00:00
|
|
|
cmd += ['--cookie', cookiefile, '--cookie-jar', cookiefile]
|
2019-06-25 23:09:43 +00:00
|
|
|
if proxy:
|
|
|
|
cmd += ['--proxy', proxy]
|
|
|
|
elif 'http_proxy' in os.environ and 'darwin' == sys.platform:
|
|
|
|
cmd += ['--proxy', os.environ['http_proxy']]
|
|
|
|
if srcUrl.startswith('persistent-https'):
|
|
|
|
srcUrl = 'http' + srcUrl[len('persistent-https'):]
|
|
|
|
elif srcUrl.startswith('persistent-http'):
|
|
|
|
srcUrl = 'http' + srcUrl[len('persistent-http'):]
|
2015-01-02 19:12:54 +00:00
|
|
|
cmd += [srcUrl]
|
|
|
|
|
|
|
|
if IsTrace():
|
|
|
|
Trace('%s', ' '.join(cmd))
|
|
|
|
try:
|
|
|
|
proc = subprocess.Popen(cmd)
|
|
|
|
except OSError:
|
|
|
|
return False
|
2011-09-19 21:50:58 +00:00
|
|
|
|
2015-01-02 19:12:54 +00:00
|
|
|
curlret = proc.wait()
|
2012-08-30 16:39:36 +00:00
|
|
|
|
2015-01-02 19:12:54 +00:00
|
|
|
if curlret == 22:
|
|
|
|
# From curl man page:
|
|
|
|
# 22: HTTP page not retrieved. The requested url was not found or
|
|
|
|
# returned another error with the HTTP error code being 400 or above.
|
|
|
|
# This return code only appears if -f, --fail is used.
|
|
|
|
if not quiet:
|
|
|
|
print("Server does not provide clone.bundle; ignoring.",
|
|
|
|
file=sys.stderr)
|
|
|
|
return False
|
2012-08-30 16:39:36 +00:00
|
|
|
|
2012-08-02 21:57:37 +00:00
|
|
|
if os.path.exists(tmpPath):
|
2014-12-23 21:02:32 +00:00
|
|
|
if curlret == 0 and self._IsValidBundle(tmpPath, quiet):
|
2016-11-01 18:34:55 +00:00
|
|
|
platform_utils.rename(tmpPath, dstPath)
|
2012-08-02 21:57:37 +00:00
|
|
|
return True
|
|
|
|
else:
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(tmpPath)
|
2012-08-02 21:57:37 +00:00
|
|
|
return False
|
|
|
|
else:
|
|
|
|
return False
|
2011-09-19 21:50:58 +00:00
|
|
|
|
2014-12-23 21:02:32 +00:00
|
|
|
def _IsValidBundle(self, path, quiet):
|
2013-06-03 19:15:23 +00:00
|
|
|
try:
|
2019-05-16 08:28:21 +00:00
|
|
|
with open(path, 'rb') as f:
|
|
|
|
if f.read(16) == b'# v2 git bundle\n':
|
2013-06-03 19:15:23 +00:00
|
|
|
return True
|
|
|
|
else:
|
2014-12-23 21:02:32 +00:00
|
|
|
if not quiet:
|
|
|
|
print("Invalid clone.bundle file; ignoring.", file=sys.stderr)
|
2013-06-03 19:15:23 +00:00
|
|
|
return False
|
|
|
|
except OSError:
|
|
|
|
return False
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def _Checkout(self, rev, quiet=False):
|
|
|
|
cmd = ['checkout']
|
|
|
|
if quiet:
|
|
|
|
cmd.append('-q')
|
|
|
|
cmd.append(rev)
|
|
|
|
cmd.append('--')
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
|
|
|
if self._allrefs:
|
|
|
|
raise GitError('%s checkout %s ' % (self.name, rev))
|
|
|
|
|
2014-07-16 11:56:40 +00:00
|
|
|
def _CherryPick(self, rev):
|
2011-03-24 15:28:18 +00:00
|
|
|
cmd = ['cherry-pick']
|
|
|
|
cmd.append(rev)
|
|
|
|
cmd.append('--')
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
|
|
|
if self._allrefs:
|
|
|
|
raise GitError('%s cherry-pick %s ' % (self.name, rev))
|
|
|
|
|
2018-03-24 06:57:05 +00:00
|
|
|
def _LsRemote(self, refs):
|
|
|
|
cmd = ['ls-remote', self.remote.name, refs]
|
2018-03-15 16:26:30 +00:00
|
|
|
p = GitCommand(self, cmd, capture_stdout=True)
|
|
|
|
if p.Wait() == 0:
|
2019-08-03 06:14:28 +00:00
|
|
|
return p.stdout
|
2018-03-15 16:26:30 +00:00
|
|
|
return None
|
|
|
|
|
2014-07-16 11:56:40 +00:00
|
|
|
def _Revert(self, rev):
|
2011-08-19 11:56:09 +00:00
|
|
|
cmd = ['revert']
|
|
|
|
cmd.append('--no-edit')
|
|
|
|
cmd.append(rev)
|
|
|
|
cmd.append('--')
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
|
|
|
if self._allrefs:
|
|
|
|
raise GitError('%s revert %s ' % (self.name, rev))
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def _ResetHard(self, rev, quiet=True):
|
|
|
|
cmd = ['reset', '--hard']
|
|
|
|
if quiet:
|
|
|
|
cmd.append('-q')
|
|
|
|
cmd.append(rev)
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
|
|
|
raise GitError('%s reset --hard %s ' % (self.name, rev))
|
|
|
|
|
2017-03-21 23:05:12 +00:00
|
|
|
def _SyncSubmodules(self, quiet=True):
|
|
|
|
cmd = ['submodule', 'update', '--init', '--recursive']
|
|
|
|
if quiet:
|
|
|
|
cmd.append('-q')
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
|
|
|
raise GitError('%s submodule update --init --recursive %s ' % self.name)
|
|
|
|
|
2014-07-16 11:56:40 +00:00
|
|
|
def _Rebase(self, upstream, onto=None):
|
2009-04-16 15:14:26 +00:00
|
|
|
cmd = ['rebase']
|
2008-10-21 14:00:00 +00:00
|
|
|
if onto is not None:
|
|
|
|
cmd.extend(['--onto', onto])
|
|
|
|
cmd.append(upstream)
|
2009-04-16 15:14:26 +00:00
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
2008-10-21 14:00:00 +00:00
|
|
|
raise GitError('%s rebase %s ' % (self.name, upstream))
|
|
|
|
|
2012-05-04 10:18:12 +00:00
|
|
|
def _FastForward(self, head, ffonly=False):
|
2008-10-21 14:00:00 +00:00
|
|
|
cmd = ['merge', head]
|
2012-05-04 10:18:12 +00:00
|
|
|
if ffonly:
|
|
|
|
cmd.append("--ff-only")
|
2008-10-21 14:00:00 +00:00
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
|
|
|
raise GitError('%s merge %s ' % (self.name, head))
|
|
|
|
|
2014-11-12 18:27:45 +00:00
|
|
|
def _InitGitDir(self, mirror_git=None, force_sync=False):
|
2014-10-16 22:02:58 +00:00
|
|
|
init_git_dir = not os.path.exists(self.gitdir)
|
|
|
|
init_obj_dir = not os.path.exists(self.objdir)
|
2015-07-27 19:33:43 +00:00
|
|
|
try:
|
|
|
|
# Initialize the bare repository, which contains all of the objects.
|
|
|
|
if init_obj_dir:
|
|
|
|
os.makedirs(self.objdir)
|
|
|
|
self.bare_objdir.init()
|
2014-10-16 22:02:58 +00:00
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
# If we have a separate directory to hold refs, initialize it as well.
|
|
|
|
if self.objdir != self.gitdir:
|
|
|
|
if init_git_dir:
|
|
|
|
os.makedirs(self.gitdir)
|
2014-10-16 22:02:58 +00:00
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
if init_obj_dir or init_git_dir:
|
|
|
|
self._ReferenceGitDir(self.objdir, self.gitdir, share_refs=False,
|
|
|
|
copy_all=True)
|
2014-11-12 18:27:45 +00:00
|
|
|
try:
|
|
|
|
self._CheckDirReference(self.objdir, self.gitdir, share_refs=False)
|
|
|
|
except GitError as e:
|
|
|
|
if force_sync:
|
2016-02-10 17:44:30 +00:00
|
|
|
print("Retrying clone after deleting %s" %
|
|
|
|
self.gitdir, file=sys.stderr)
|
2014-11-12 18:27:45 +00:00
|
|
|
try:
|
2016-11-01 21:37:13 +00:00
|
|
|
platform_utils.rmtree(platform_utils.realpath(self.gitdir))
|
|
|
|
if self.worktree and os.path.exists(platform_utils.realpath
|
2016-02-10 17:44:30 +00:00
|
|
|
(self.worktree)):
|
2016-11-01 21:37:13 +00:00
|
|
|
platform_utils.rmtree(platform_utils.realpath(self.worktree))
|
2014-11-12 18:27:45 +00:00
|
|
|
return self._InitGitDir(mirror_git=mirror_git, force_sync=False)
|
|
|
|
except:
|
|
|
|
raise e
|
|
|
|
raise e
|
2009-03-04 01:53:18 +00:00
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
if init_git_dir:
|
|
|
|
mp = self.manifest.manifestProject
|
|
|
|
ref_dir = mp.config.GetString('repo.reference') or ''
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
if ref_dir or mirror_git:
|
|
|
|
if not mirror_git:
|
|
|
|
mirror_git = os.path.join(ref_dir, self.name + '.git')
|
|
|
|
repo_git = os.path.join(ref_dir, '.repo', 'projects',
|
|
|
|
self.relpath + '.git')
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
if os.path.exists(mirror_git):
|
|
|
|
ref_dir = mirror_git
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
elif os.path.exists(repo_git):
|
|
|
|
ref_dir = repo_git
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
else:
|
|
|
|
ref_dir = None
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
if ref_dir:
|
2018-01-22 16:57:29 +00:00
|
|
|
if not os.path.isabs(ref_dir):
|
|
|
|
# The alternate directory is relative to the object database.
|
|
|
|
ref_dir = os.path.relpath(ref_dir,
|
|
|
|
os.path.join(self.objdir, 'objects'))
|
2015-07-27 19:33:43 +00:00
|
|
|
_lwrite(os.path.join(self.gitdir, 'objects/info/alternates'),
|
|
|
|
os.path.join(ref_dir, 'objects') + '\n')
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
self._UpdateHooks()
|
2012-10-24 11:44:42 +00:00
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
m = self.manifest.manifestProject.config
|
|
|
|
for key in ['user.name', 'user.email']:
|
|
|
|
if m.Has(key, include_defaults=False):
|
|
|
|
self.config.SetString(key, m.GetString(key))
|
2016-08-16 03:11:12 +00:00
|
|
|
self.config.SetString('filter.lfs.smudge', 'git-lfs smudge --skip -- %f')
|
2019-05-24 07:35:20 +00:00
|
|
|
self.config.SetString('filter.lfs.process', 'git-lfs filter-process --skip')
|
2015-07-27 19:33:43 +00:00
|
|
|
if self.manifest.IsMirror:
|
|
|
|
self.config.SetString('core.bare', 'true')
|
|
|
|
else:
|
|
|
|
self.config.SetString('core.bare', None)
|
|
|
|
except Exception:
|
|
|
|
if init_obj_dir and os.path.exists(self.objdir):
|
2016-11-03 17:37:53 +00:00
|
|
|
platform_utils.rmtree(self.objdir)
|
2015-07-27 19:33:43 +00:00
|
|
|
if init_git_dir and os.path.exists(self.gitdir):
|
2016-11-03 17:37:53 +00:00
|
|
|
platform_utils.rmtree(self.gitdir)
|
2015-07-27 19:33:43 +00:00
|
|
|
raise
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2012-10-24 11:44:42 +00:00
|
|
|
def _UpdateHooks(self):
|
|
|
|
if os.path.exists(self.gitdir):
|
2008-11-03 18:32:09 +00:00
|
|
|
self._InitHooks()
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2008-11-03 18:32:09 +00:00
|
|
|
def _InitHooks(self):
|
2016-11-01 21:37:13 +00:00
|
|
|
hooks = platform_utils.realpath(self._gitdir_path('hooks'))
|
2008-11-03 18:32:09 +00:00
|
|
|
if not os.path.exists(hooks):
|
|
|
|
os.makedirs(hooks)
|
2015-03-17 18:29:58 +00:00
|
|
|
for stock_hook in _ProjectHooks():
|
2009-08-23 01:17:46 +00:00
|
|
|
name = os.path.basename(stock_hook)
|
|
|
|
|
2011-04-18 09:23:29 +00:00
|
|
|
if name in ('commit-msg',) and not self.remote.review \
|
2016-02-10 17:44:30 +00:00
|
|
|
and self is not self.manifest.manifestProject:
|
2009-08-23 01:17:46 +00:00
|
|
|
# Don't install a Gerrit Code Review hook if this
|
|
|
|
# project does not appear to use it for reviews.
|
|
|
|
#
|
2011-04-18 09:23:29 +00:00
|
|
|
# Since the manifest project is one of those, but also
|
|
|
|
# managed through gerrit, it's excluded
|
2009-08-23 01:17:46 +00:00
|
|
|
continue
|
|
|
|
|
|
|
|
dst = os.path.join(hooks, name)
|
2016-11-01 21:37:13 +00:00
|
|
|
if platform_utils.islink(dst):
|
2009-08-23 01:17:46 +00:00
|
|
|
continue
|
|
|
|
if os.path.exists(dst):
|
|
|
|
if filecmp.cmp(stock_hook, dst, shallow=False):
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(dst)
|
2009-08-23 01:17:46 +00:00
|
|
|
else:
|
2016-02-10 17:44:30 +00:00
|
|
|
_warn("%s: Not replacing locally modified %s hook",
|
|
|
|
self.relpath, name)
|
2009-08-23 01:17:46 +00:00
|
|
|
continue
|
2008-11-03 18:32:09 +00:00
|
|
|
try:
|
2016-11-01 18:24:03 +00:00
|
|
|
platform_utils.symlink(
|
|
|
|
os.path.relpath(stock_hook, os.path.dirname(dst)), dst)
|
2012-09-09 22:37:57 +00:00
|
|
|
except OSError as e:
|
2009-08-23 01:17:46 +00:00
|
|
|
if e.errno == errno.EPERM:
|
2017-01-27 19:41:12 +00:00
|
|
|
raise GitError(self._get_symlink_error_message())
|
2008-11-03 18:32:09 +00:00
|
|
|
else:
|
|
|
|
raise
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def _InitRemote(self):
|
2009-05-19 21:58:02 +00:00
|
|
|
if self.remote.url:
|
2008-10-21 14:00:00 +00:00
|
|
|
remote = self.GetRemote(self.remote.name)
|
2009-05-19 21:58:02 +00:00
|
|
|
remote.url = self.remote.url
|
2016-08-10 22:00:00 +00:00
|
|
|
remote.pushUrl = self.remote.pushUrl
|
2009-05-19 21:58:02 +00:00
|
|
|
remote.review = self.remote.review
|
|
|
|
remote.projectname = self.name
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2008-11-04 15:37:10 +00:00
|
|
|
if self.worktree:
|
|
|
|
remote.ResetFetch(mirror=False)
|
|
|
|
else:
|
|
|
|
remote.ResetFetch(mirror=True)
|
2008-10-21 14:00:00 +00:00
|
|
|
remote.Save()
|
|
|
|
|
|
|
|
def _InitMRef(self):
|
|
|
|
if self.manifest.branch:
|
2009-05-30 01:38:17 +00:00
|
|
|
self._InitAnyMRef(R_M + self.manifest.branch)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2008-11-04 15:37:10 +00:00
|
|
|
def _InitMirrorHead(self):
|
2009-06-01 22:28:21 +00:00
|
|
|
self._InitAnyMRef(HEAD)
|
2009-05-30 01:38:17 +00:00
|
|
|
|
|
|
|
def _InitAnyMRef(self, ref):
|
|
|
|
cur = self.bare_ref.symref(ref)
|
|
|
|
|
|
|
|
if self.revisionId:
|
|
|
|
if cur != '' or self.bare_ref.get(ref) != self.revisionId:
|
|
|
|
msg = 'manifest set to %s' % self.revisionId
|
|
|
|
dst = self.revisionId + '^0'
|
2014-07-16 11:56:40 +00:00
|
|
|
self.bare_git.UpdateRef(ref, dst, message=msg, detach=True)
|
2009-05-30 01:38:17 +00:00
|
|
|
else:
|
|
|
|
remote = self.GetRemote(self.remote.name)
|
|
|
|
dst = remote.ToLocal(self.revisionExpr)
|
|
|
|
if cur != dst:
|
|
|
|
msg = 'manifest set to %s' % self.revisionExpr
|
|
|
|
self.bare_git.symbolic_ref('-m', msg, ref, dst)
|
2008-11-04 15:37:10 +00:00
|
|
|
|
2014-10-16 22:02:58 +00:00
|
|
|
def _CheckDirReference(self, srcdir, destdir, share_refs):
|
2016-04-06 00:22:02 +00:00
|
|
|
symlink_files = self.shareable_files[:]
|
|
|
|
symlink_dirs = self.shareable_dirs[:]
|
2014-10-16 22:02:58 +00:00
|
|
|
if share_refs:
|
|
|
|
symlink_files += self.working_tree_files
|
|
|
|
symlink_dirs += self.working_tree_dirs
|
|
|
|
to_symlink = symlink_files + symlink_dirs
|
|
|
|
for name in set(to_symlink):
|
2016-11-01 21:37:13 +00:00
|
|
|
dst = platform_utils.realpath(os.path.join(destdir, name))
|
2014-10-16 22:02:58 +00:00
|
|
|
if os.path.lexists(dst):
|
2016-11-01 21:37:13 +00:00
|
|
|
src = platform_utils.realpath(os.path.join(srcdir, name))
|
2014-10-16 22:02:58 +00:00
|
|
|
# Fail if the links are pointing to the wrong place
|
|
|
|
if src != dst:
|
2016-10-27 19:58:26 +00:00
|
|
|
_error('%s is different in %s vs %s', name, destdir, srcdir)
|
2014-11-12 18:27:45 +00:00
|
|
|
raise GitError('--force-sync not enabled; cannot overwrite a local '
|
2015-07-31 21:18:34 +00:00
|
|
|
'work tree. If you\'re comfortable with the '
|
|
|
|
'possibility of losing the work tree\'s git metadata,'
|
|
|
|
' use `repo sync --force-sync {0}` to '
|
|
|
|
'proceed.'.format(self.relpath))
|
2014-10-16 22:02:58 +00:00
|
|
|
|
2013-10-12 00:03:19 +00:00
|
|
|
def _ReferenceGitDir(self, gitdir, dotgit, share_refs, copy_all):
|
|
|
|
"""Update |dotgit| to reference |gitdir|, using symlinks where possible.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
gitdir: The bare git repository. Must already be initialized.
|
|
|
|
dotgit: The repository you would like to initialize.
|
|
|
|
share_refs: If true, |dotgit| will store its refs under |gitdir|.
|
|
|
|
Only one work tree can store refs under a given |gitdir|.
|
|
|
|
copy_all: If true, copy all remaining files from |gitdir| -> |dotgit|.
|
|
|
|
This saves you the effort of initializing |dotgit| yourself.
|
|
|
|
"""
|
2016-04-06 00:22:02 +00:00
|
|
|
symlink_files = self.shareable_files[:]
|
|
|
|
symlink_dirs = self.shareable_dirs[:]
|
2013-10-12 00:03:19 +00:00
|
|
|
if share_refs:
|
2014-10-16 22:02:58 +00:00
|
|
|
symlink_files += self.working_tree_files
|
|
|
|
symlink_dirs += self.working_tree_dirs
|
2013-10-12 00:03:19 +00:00
|
|
|
to_symlink = symlink_files + symlink_dirs
|
|
|
|
|
|
|
|
to_copy = []
|
|
|
|
if copy_all:
|
2018-09-27 17:46:58 +00:00
|
|
|
to_copy = platform_utils.listdir(gitdir)
|
2013-10-12 00:03:19 +00:00
|
|
|
|
2016-11-01 21:37:13 +00:00
|
|
|
dotgit = platform_utils.realpath(dotgit)
|
2013-10-12 00:03:19 +00:00
|
|
|
for name in set(to_copy).union(to_symlink):
|
|
|
|
try:
|
2016-11-01 21:37:13 +00:00
|
|
|
src = platform_utils.realpath(os.path.join(gitdir, name))
|
Fix _ReferenceGitDir symlinking
This fixes these errors:
...
File ".repo/repo/project.py", line 2371, in _ReferenceGitDir
os.symlink(os.path.relpath(src, os.path.dirname(dst)), dst)
OSError: [Errno 17] File exists
Which was happening for checkouts that were created before v1.12.8, when
project-objects was created. Nothing had yet been forcing these
checkouts to use project-objects, until the recent verification changes.
In this OSError case, we already created the symlink, so src == dst, and
the directory did not exist. This caused us to run os.makedirs the
os.symlink on the same file.
dst really should be the file in gitdir, not the target of that symlink
if it exists. So just use realpath for the dotgit portion of the path.
Change-Id: Iff5396a2093de91029c42cf38aa57131fd22981c
2015-07-31 03:43:33 +00:00
|
|
|
dst = os.path.join(dotgit, name)
|
2013-10-12 00:03:19 +00:00
|
|
|
|
2014-10-16 22:02:58 +00:00
|
|
|
if os.path.lexists(dst):
|
|
|
|
continue
|
2013-10-12 00:03:19 +00:00
|
|
|
|
|
|
|
# If the source dir doesn't exist, create an empty dir.
|
|
|
|
if name in symlink_dirs and not os.path.lexists(src):
|
|
|
|
os.makedirs(src)
|
|
|
|
|
2015-07-06 19:33:00 +00:00
|
|
|
if name in to_symlink:
|
2016-11-01 18:24:03 +00:00
|
|
|
platform_utils.symlink(
|
|
|
|
os.path.relpath(src, os.path.dirname(dst)), dst)
|
2016-11-01 21:37:13 +00:00
|
|
|
elif copy_all and not platform_utils.islink(dst):
|
2018-09-27 17:46:58 +00:00
|
|
|
if platform_utils.isdir(src):
|
2015-07-06 19:33:00 +00:00
|
|
|
shutil.copytree(src, dst)
|
|
|
|
elif os.path.isfile(src):
|
|
|
|
shutil.copy(src, dst)
|
|
|
|
|
2014-05-10 00:13:44 +00:00
|
|
|
# If the source file doesn't exist, ensure the destination
|
|
|
|
# file doesn't either.
|
|
|
|
if name in symlink_files and not os.path.lexists(src):
|
|
|
|
try:
|
2016-11-11 22:25:29 +00:00
|
|
|
platform_utils.remove(dst)
|
2014-05-10 00:13:44 +00:00
|
|
|
except OSError:
|
|
|
|
pass
|
|
|
|
|
2013-10-12 00:03:19 +00:00
|
|
|
except OSError as e:
|
|
|
|
if e.errno == errno.EPERM:
|
2017-01-27 19:41:12 +00:00
|
|
|
raise DownloadError(self._get_symlink_error_message())
|
2013-10-12 00:03:19 +00:00
|
|
|
else:
|
|
|
|
raise
|
|
|
|
|
2017-03-21 23:05:12 +00:00
|
|
|
def _InitWorkTree(self, force_sync=False, submodules=False):
|
2019-11-11 09:34:16 +00:00
|
|
|
realdotgit = os.path.join(self.worktree, '.git')
|
|
|
|
tmpdotgit = realdotgit + '.tmp'
|
|
|
|
init_dotgit = not os.path.exists(realdotgit)
|
|
|
|
if init_dotgit:
|
|
|
|
dotgit = tmpdotgit
|
|
|
|
platform_utils.rmtree(tmpdotgit, ignore_errors=True)
|
|
|
|
os.makedirs(tmpdotgit)
|
|
|
|
self._ReferenceGitDir(self.gitdir, tmpdotgit, share_refs=True,
|
|
|
|
copy_all=False)
|
|
|
|
else:
|
|
|
|
dotgit = realdotgit
|
|
|
|
|
2015-07-27 19:33:43 +00:00
|
|
|
try:
|
2019-11-11 09:34:16 +00:00
|
|
|
self._CheckDirReference(self.gitdir, dotgit, share_refs=True)
|
|
|
|
except GitError as e:
|
|
|
|
if force_sync and not init_dotgit:
|
|
|
|
try:
|
|
|
|
platform_utils.rmtree(dotgit)
|
|
|
|
return self._InitWorkTree(force_sync=False, submodules=submodules)
|
|
|
|
except:
|
|
|
|
raise e
|
|
|
|
raise e
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2019-11-11 09:34:16 +00:00
|
|
|
if init_dotgit:
|
|
|
|
_lwrite(os.path.join(tmpdotgit, HEAD), '%s\n' % self.GetRevisionId())
|
2014-10-16 22:02:58 +00:00
|
|
|
|
2019-11-11 09:34:16 +00:00
|
|
|
# Now that the .git dir is fully set up, move it to its final home.
|
|
|
|
platform_utils.rename(tmpdotgit, realdotgit)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2019-11-11 09:34:16 +00:00
|
|
|
# Finish checking out the worktree.
|
|
|
|
cmd = ['read-tree', '--reset', '-u']
|
|
|
|
cmd.append('-v')
|
|
|
|
cmd.append(HEAD)
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
|
|
|
raise GitError('Cannot initialize work tree for ' + self.name)
|
2010-11-26 12:42:13 +00:00
|
|
|
|
2019-11-11 09:34:16 +00:00
|
|
|
if submodules:
|
|
|
|
self._SyncSubmodules(quiet=True)
|
|
|
|
self._CopyAndLinkFiles()
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2017-01-27 19:41:12 +00:00
|
|
|
def _get_symlink_error_message(self):
|
|
|
|
if platform_utils.isWindows():
|
|
|
|
return ('Unable to create symbolic link. Please re-run the command as '
|
|
|
|
'Administrator, or see '
|
|
|
|
'https://github.com/git-for-windows/git/wiki/Symbolic-Links '
|
|
|
|
'for other options.')
|
|
|
|
return 'filesystem must support symlinks'
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def _gitdir_path(self, path):
|
2016-11-01 21:37:13 +00:00
|
|
|
return platform_utils.realpath(os.path.join(self.gitdir, path))
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-05-30 01:28:25 +00:00
|
|
|
def _revlist(self, *args, **kw):
|
|
|
|
a = []
|
|
|
|
a.extend(args)
|
|
|
|
a.append('--')
|
|
|
|
return self.work_git.rev_list(*a, **kw)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
@property
|
|
|
|
def _allrefs(self):
|
2009-04-18 01:49:50 +00:00
|
|
|
return self.bare_ref.all
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2016-03-29 12:11:20 +00:00
|
|
|
def _getLogs(self, rev1, rev2, oneline=False, color=True, pretty_format=None):
|
2014-01-09 15:21:37 +00:00
|
|
|
"""Get logs between two revisions of this project."""
|
|
|
|
comp = '..'
|
|
|
|
if rev1:
|
|
|
|
revs = [rev1]
|
|
|
|
if rev2:
|
|
|
|
revs.extend([comp, rev2])
|
|
|
|
cmd = ['log', ''.join(revs)]
|
|
|
|
out = DiffColoring(self.config)
|
|
|
|
if out.is_on and color:
|
|
|
|
cmd.append('--color')
|
2016-03-29 12:11:20 +00:00
|
|
|
if pretty_format is not None:
|
|
|
|
cmd.append('--pretty=format:%s' % pretty_format)
|
2014-01-09 15:21:37 +00:00
|
|
|
if oneline:
|
|
|
|
cmd.append('--oneline')
|
|
|
|
|
|
|
|
try:
|
|
|
|
log = GitCommand(self, cmd, capture_stdout=True, capture_stderr=True)
|
|
|
|
if log.Wait() == 0:
|
|
|
|
return log.stdout
|
|
|
|
except GitError:
|
|
|
|
# worktree may not exist if groups changed for example. In that case,
|
|
|
|
# try in gitdir instead.
|
|
|
|
if not os.path.exists(self.worktree):
|
|
|
|
return self.bare_git.log(*cmd[1:])
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
return None
|
|
|
|
|
2016-03-29 12:11:20 +00:00
|
|
|
def getAddedAndRemovedLogs(self, toProject, oneline=False, color=True,
|
|
|
|
pretty_format=None):
|
2014-01-09 15:21:37 +00:00
|
|
|
"""Get the list of logs from this revision to given revisionId"""
|
|
|
|
logs = {}
|
|
|
|
selfId = self.GetRevisionId(self._allrefs)
|
|
|
|
toId = toProject.GetRevisionId(toProject._allrefs)
|
|
|
|
|
2016-03-29 12:11:20 +00:00
|
|
|
logs['added'] = self._getLogs(selfId, toId, oneline=oneline, color=color,
|
|
|
|
pretty_format=pretty_format)
|
|
|
|
logs['removed'] = self._getLogs(toId, selfId, oneline=oneline, color=color,
|
|
|
|
pretty_format=pretty_format)
|
2014-01-09 15:21:37 +00:00
|
|
|
return logs
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
class _GitGetByExec(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2013-10-12 00:03:19 +00:00
|
|
|
def __init__(self, project, bare, gitdir):
|
2008-10-21 14:00:00 +00:00
|
|
|
self._project = project
|
|
|
|
self._bare = bare
|
2013-10-12 00:03:19 +00:00
|
|
|
self._gitdir = gitdir
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
def LsOthers(self):
|
|
|
|
p = GitCommand(self._project,
|
|
|
|
['ls-files',
|
|
|
|
'-z',
|
|
|
|
'--others',
|
|
|
|
'--exclude-standard'],
|
2014-07-16 11:56:40 +00:00
|
|
|
bare=False,
|
2013-10-12 00:03:19 +00:00
|
|
|
gitdir=self._gitdir,
|
2014-07-16 11:56:40 +00:00
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True)
|
2008-10-21 14:00:00 +00:00
|
|
|
if p.Wait() == 0:
|
|
|
|
out = p.stdout
|
|
|
|
if out:
|
2016-02-10 17:44:30 +00:00
|
|
|
# Backslash is not anomalous
|
2018-06-24 07:21:51 +00:00
|
|
|
return out[:-1].split('\0')
|
2008-10-21 14:00:00 +00:00
|
|
|
return []
|
|
|
|
|
|
|
|
def DiffZ(self, name, *args):
|
|
|
|
cmd = [name]
|
|
|
|
cmd.append('-z')
|
2019-05-03 01:21:42 +00:00
|
|
|
cmd.append('--ignore-submodules')
|
2008-10-21 14:00:00 +00:00
|
|
|
cmd.extend(args)
|
|
|
|
p = GitCommand(self._project,
|
|
|
|
cmd,
|
2013-10-12 00:03:19 +00:00
|
|
|
gitdir=self._gitdir,
|
2014-07-16 11:56:40 +00:00
|
|
|
bare=False,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True)
|
2008-10-21 14:00:00 +00:00
|
|
|
try:
|
|
|
|
out = p.process.stdout.read()
|
2019-08-03 06:14:28 +00:00
|
|
|
if not hasattr(out, 'encode'):
|
|
|
|
out = out.decode()
|
2008-10-21 14:00:00 +00:00
|
|
|
r = {}
|
|
|
|
if out:
|
2018-06-24 07:21:51 +00:00
|
|
|
out = iter(out[:-1].split('\0'))
|
2008-10-21 14:00:00 +00:00
|
|
|
while out:
|
2008-10-21 20:59:08 +00:00
|
|
|
try:
|
2014-05-05 20:24:05 +00:00
|
|
|
info = next(out)
|
|
|
|
path = next(out)
|
2008-10-21 20:59:08 +00:00
|
|
|
except StopIteration:
|
|
|
|
break
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
class _Info(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def __init__(self, path, omode, nmode, oid, nid, state):
|
|
|
|
self.path = path
|
|
|
|
self.src_path = None
|
|
|
|
self.old_mode = omode
|
|
|
|
self.new_mode = nmode
|
|
|
|
self.old_id = oid
|
|
|
|
self.new_id = nid
|
|
|
|
|
|
|
|
if len(state) == 1:
|
|
|
|
self.status = state
|
|
|
|
self.level = None
|
|
|
|
else:
|
|
|
|
self.status = state[:1]
|
|
|
|
self.level = state[1:]
|
|
|
|
while self.level.startswith('0'):
|
|
|
|
self.level = self.level[1:]
|
|
|
|
|
|
|
|
info = info[1:].split(' ')
|
2012-11-14 03:09:38 +00:00
|
|
|
info = _Info(path, *info)
|
2008-10-21 14:00:00 +00:00
|
|
|
if info.status in ('R', 'C'):
|
|
|
|
info.src_path = info.path
|
2014-05-05 20:24:05 +00:00
|
|
|
info.path = next(out)
|
2008-10-21 14:00:00 +00:00
|
|
|
r[info.path] = info
|
|
|
|
return r
|
|
|
|
finally:
|
|
|
|
p.Wait()
|
|
|
|
|
|
|
|
def GetHead(self):
|
2009-04-18 01:43:33 +00:00
|
|
|
if self._bare:
|
|
|
|
path = os.path.join(self._project.gitdir, HEAD)
|
|
|
|
else:
|
|
|
|
path = os.path.join(self._project.worktree, '.git', HEAD)
|
2012-11-16 01:33:11 +00:00
|
|
|
try:
|
2019-11-11 10:40:22 +00:00
|
|
|
with open(path) as fd:
|
|
|
|
line = fd.readline()
|
2014-03-09 17:20:02 +00:00
|
|
|
except IOError as e:
|
|
|
|
raise NoManifestException(path, str(e))
|
2013-03-01 13:44:38 +00:00
|
|
|
try:
|
|
|
|
line = line.decode()
|
|
|
|
except AttributeError:
|
|
|
|
pass
|
2009-04-18 01:43:33 +00:00
|
|
|
if line.startswith('ref: '):
|
|
|
|
return line[5:-1]
|
|
|
|
return line[:-1]
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
def SetHead(self, ref, message=None):
|
|
|
|
cmdv = []
|
|
|
|
if message is not None:
|
|
|
|
cmdv.extend(['-m', message])
|
|
|
|
cmdv.append(HEAD)
|
|
|
|
cmdv.append(ref)
|
|
|
|
self.symbolic_ref(*cmdv)
|
|
|
|
|
|
|
|
def DetachHead(self, new, message=None):
|
|
|
|
cmdv = ['--no-deref']
|
|
|
|
if message is not None:
|
|
|
|
cmdv.extend(['-m', message])
|
|
|
|
cmdv.append(HEAD)
|
|
|
|
cmdv.append(new)
|
|
|
|
self.update_ref(*cmdv)
|
|
|
|
|
|
|
|
def UpdateRef(self, name, new, old=None,
|
|
|
|
message=None,
|
|
|
|
detach=False):
|
|
|
|
cmdv = []
|
|
|
|
if message is not None:
|
|
|
|
cmdv.extend(['-m', message])
|
|
|
|
if detach:
|
|
|
|
cmdv.append('--no-deref')
|
|
|
|
cmdv.append(name)
|
|
|
|
cmdv.append(new)
|
|
|
|
if old is not None:
|
|
|
|
cmdv.append(old)
|
|
|
|
self.update_ref(*cmdv)
|
|
|
|
|
|
|
|
def DeleteRef(self, name, old=None):
|
|
|
|
if not old:
|
|
|
|
old = self.rev_parse(name)
|
|
|
|
self.update_ref('-d', name, old)
|
2009-04-18 03:58:02 +00:00
|
|
|
self._project.bare_ref.deleted(name)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2009-05-30 01:28:25 +00:00
|
|
|
def rev_list(self, *args, **kw):
|
|
|
|
if 'format' in kw:
|
|
|
|
cmdv = ['log', '--pretty=format:%s' % kw['format']]
|
|
|
|
else:
|
|
|
|
cmdv = ['rev-list']
|
2008-10-21 14:00:00 +00:00
|
|
|
cmdv.extend(args)
|
|
|
|
p = GitCommand(self._project,
|
|
|
|
cmdv,
|
2014-07-16 11:56:40 +00:00
|
|
|
bare=self._bare,
|
2013-10-12 00:03:19 +00:00
|
|
|
gitdir=self._gitdir,
|
2014-07-16 11:56:40 +00:00
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True)
|
2008-10-21 14:00:00 +00:00
|
|
|
if p.Wait() != 0:
|
2016-02-10 17:44:30 +00:00
|
|
|
raise GitError('%s rev-list %s: %s' %
|
|
|
|
(self._project.name, str(args), p.stderr))
|
2019-07-04 22:13:31 +00:00
|
|
|
return p.stdout.splitlines()
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
def __getattr__(self, name):
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
"""Allow arbitrary git commands using pythonic syntax.
|
|
|
|
|
|
|
|
This allows you to do things like:
|
|
|
|
git_obj.rev_parse('HEAD')
|
|
|
|
|
|
|
|
Since we don't have a 'rev_parse' method defined, the __getattr__ will
|
|
|
|
run. We'll replace the '_' with a '-' and try to run a git command.
|
2012-10-24 00:01:04 +00:00
|
|
|
Any other positional arguments will be passed to the git command, and the
|
|
|
|
following keyword arguments are supported:
|
|
|
|
config: An optional dict of git config options to be passed with '-c'.
|
Support repo-level pre-upload hook and prep for future hooks.
All repo-level hooks are expected to live in a single project at the
top level of that project. The name of the hooks project is provided
in the manifest.xml. The manifest also lists which hooks are enabled
to make it obvious if a file somehow failed to sync down (or got
deleted).
Before running any hook, we will prompt the user to make sure that it
is OK. A user can deny running the hook, allow once, or allow
"forever" (until hooks change). This tries to keep with the git
spirit of not automatically running anything on the user's computer
that got synced down. Note that individual repo commands can add
always options to avoid these prompts as they see fit (see below for
the 'upload' options).
When hooks are run, they are loaded into the current interpreter (the
one running repo) and their main() function is run. This mechanism is
used (instead of using subprocess) to make it easier to expand to a
richer hook interface in the future. During loading, the
interpreter's sys.path is updated to contain the directory containing
the hooks so that hooks can be split into multiple files.
The upload command has two options that control hook behavior:
- no-verify=False, verify=False (DEFAULT):
If stdout is a tty, can prompt about running upload hooks if needed.
If user denies running hooks, the upload is cancelled. If stdout is
not a tty and we would need to prompt about upload hooks, upload is
cancelled.
- no-verify=False, verify=True:
Always run upload hooks with no prompt.
- no-verify=True, verify=False:
Never run upload hooks, but upload anyway (AKA bypass hooks).
- no-verify=True, verify=True:
Invalid
Sample bit of manifest.xml code for enabling hooks (assumes you have a
project named 'hooks' where hooks are stored):
<repo-hooks in-project="hooks" enabled-list="pre-upload" />
Sample main() function in pre-upload.py in hooks directory:
def main(project_list, **kwargs):
print ('These projects will be uploaded: %s' %
', '.join(project_list))
print ('I am being a good boy and ignoring anything in kwargs\n'
'that I don\'t understand.')
print 'I fail 50% of the time. How flaky.'
if random.random() <= .5:
raise Exception('Pre-upload hook failed. Have a nice day.')
Change-Id: I5cefa2cd5865c72589263cf8e2f152a43c122f70
2011-03-04 19:54:18 +00:00
|
|
|
|
|
|
|
Args:
|
|
|
|
name: The name of the git command to call. Any '_' characters will
|
|
|
|
be replaced with '-'.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
A callable object that will try to call git with the named command.
|
|
|
|
"""
|
2008-10-21 14:00:00 +00:00
|
|
|
name = name.replace('_', '-')
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2012-10-24 00:01:04 +00:00
|
|
|
def runner(*args, **kwargs):
|
|
|
|
cmdv = []
|
|
|
|
config = kwargs.pop('config', None)
|
|
|
|
for k in kwargs:
|
|
|
|
raise TypeError('%s() got an unexpected keyword argument %r'
|
|
|
|
% (name, k))
|
|
|
|
if config is not None:
|
2012-10-31 19:27:27 +00:00
|
|
|
if not git_require((1, 7, 2)):
|
|
|
|
raise ValueError('cannot set config on command line for %s()'
|
|
|
|
% name)
|
2013-03-01 13:44:38 +00:00
|
|
|
for k, v in config.items():
|
2012-10-24 00:01:04 +00:00
|
|
|
cmdv.append('-c')
|
|
|
|
cmdv.append('%s=%s' % (k, v))
|
|
|
|
cmdv.append(name)
|
2008-10-21 14:00:00 +00:00
|
|
|
cmdv.extend(args)
|
|
|
|
p = GitCommand(self._project,
|
|
|
|
cmdv,
|
2014-07-16 11:56:40 +00:00
|
|
|
bare=self._bare,
|
2013-10-12 00:03:19 +00:00
|
|
|
gitdir=self._gitdir,
|
2014-07-16 11:56:40 +00:00
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True)
|
2008-10-21 14:00:00 +00:00
|
|
|
if p.Wait() != 0:
|
2016-02-10 17:44:30 +00:00
|
|
|
raise GitError('%s %s: %s' %
|
|
|
|
(self._project.name, name, p.stderr))
|
2008-10-21 14:00:00 +00:00
|
|
|
r = p.stdout
|
|
|
|
if r.endswith('\n') and r.index('\n') == len(r) - 1:
|
|
|
|
return r[:-1]
|
|
|
|
return r
|
|
|
|
return runner
|
|
|
|
|
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
class _PriorSyncFailedError(Exception):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
def __str__(self):
|
|
|
|
return 'prior sync failed; rebase still in progress'
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
class _DirtyError(Exception):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
def __str__(self):
|
|
|
|
return 'contains uncommitted changes'
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
class _InfoMessage(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
def __init__(self, project, text):
|
|
|
|
self.project = project
|
|
|
|
self.text = text
|
|
|
|
|
|
|
|
def Print(self, syncbuf):
|
|
|
|
syncbuf.out.info('%s/: %s', self.project.relpath, self.text)
|
|
|
|
syncbuf.out.nl()
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
class _Failure(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
def __init__(self, project, why):
|
|
|
|
self.project = project
|
|
|
|
self.why = why
|
|
|
|
|
|
|
|
def Print(self, syncbuf):
|
|
|
|
syncbuf.out.fail('error: %s/: %s',
|
|
|
|
self.project.relpath,
|
|
|
|
str(self.why))
|
|
|
|
syncbuf.out.nl()
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
class _Later(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
def __init__(self, project, action):
|
|
|
|
self.project = project
|
|
|
|
self.action = action
|
|
|
|
|
|
|
|
def Run(self, syncbuf):
|
|
|
|
out = syncbuf.out
|
|
|
|
out.project('project %s/', self.project.relpath)
|
|
|
|
out.nl()
|
|
|
|
try:
|
|
|
|
self.action()
|
|
|
|
out.nl()
|
|
|
|
return True
|
2012-09-24 03:15:13 +00:00
|
|
|
except GitError:
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
out.nl()
|
|
|
|
return False
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
class _SyncColoring(Coloring):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
def __init__(self, config):
|
|
|
|
Coloring.__init__(self, config, 'reposync')
|
2014-07-16 11:56:40 +00:00
|
|
|
self.project = self.printer('header', attr='bold')
|
|
|
|
self.info = self.printer('info')
|
|
|
|
self.fail = self.printer('fail', fg='red')
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
class SyncBuffer(object):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
def __init__(self, config, detach_head=False):
|
|
|
|
self._messages = []
|
|
|
|
self._failures = []
|
|
|
|
self._later_queue1 = []
|
|
|
|
self._later_queue2 = []
|
|
|
|
|
|
|
|
self.out = _SyncColoring(config)
|
|
|
|
self.out.redirect(sys.stderr)
|
|
|
|
|
|
|
|
self.detach_head = detach_head
|
|
|
|
self.clean = True
|
2017-04-05 07:02:59 +00:00
|
|
|
self.recent_clean = True
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
|
|
|
|
def info(self, project, fmt, *args):
|
|
|
|
self._messages.append(_InfoMessage(project, fmt % args))
|
|
|
|
|
|
|
|
def fail(self, project, err=None):
|
|
|
|
self._failures.append(_Failure(project, err))
|
2017-04-05 07:02:59 +00:00
|
|
|
self._MarkUnclean()
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
|
|
|
|
def later1(self, project, what):
|
|
|
|
self._later_queue1.append(_Later(project, what))
|
|
|
|
|
|
|
|
def later2(self, project, what):
|
|
|
|
self._later_queue2.append(_Later(project, what))
|
|
|
|
|
|
|
|
def Finish(self):
|
|
|
|
self._PrintMessages()
|
|
|
|
self._RunLater()
|
|
|
|
self._PrintMessages()
|
|
|
|
return self.clean
|
|
|
|
|
2017-04-05 07:02:59 +00:00
|
|
|
def Recently(self):
|
|
|
|
recent_clean = self.recent_clean
|
|
|
|
self.recent_clean = True
|
|
|
|
return recent_clean
|
|
|
|
|
|
|
|
def _MarkUnclean(self):
|
|
|
|
self.clean = False
|
|
|
|
self.recent_clean = False
|
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
def _RunLater(self):
|
|
|
|
for q in ['_later_queue1', '_later_queue2']:
|
|
|
|
if not self._RunQueue(q):
|
|
|
|
return
|
|
|
|
|
|
|
|
def _RunQueue(self, queue):
|
|
|
|
for m in getattr(self, queue):
|
|
|
|
if not m.Run(self):
|
2017-04-05 07:02:59 +00:00
|
|
|
self._MarkUnclean()
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
return False
|
|
|
|
setattr(self, queue, [])
|
|
|
|
return True
|
|
|
|
|
|
|
|
def _PrintMessages(self):
|
2019-08-26 19:22:36 +00:00
|
|
|
if self._messages or self._failures:
|
|
|
|
if os.isatty(2):
|
|
|
|
self.out.write(progress.CSI_ERASE_LINE)
|
|
|
|
self.out.write('\r')
|
|
|
|
|
Change repo sync to be more friendly when updating the tree
We now try to sync all projects that can be done safely first, before
we start rebasing user commits over the upstream. This has the nice
effect of making the local tree as close to the upstream as possible
before the user has to start resolving merge conflicts, as that extra
information in other projects may aid in the conflict resolution.
Informational output is buffered and delayed until calculation for
all projects has been done, so that the user gets one concise list
of notice messages, rather than it interrupting the progress meter.
Fast-forward output is now prefixed with the project header, so the
user can see which project that update is taking place in, and make
some relation of the diffstat back to the project name.
Rebase output is now prefixed with the project header, so that if
the rebase fails, the user can see which project we were operating
on and can try to address the failure themselves.
Since rebase sits on a detached HEAD, we now look for an in-progress
rebase during sync, so we can alert the user that the given project
is in a state we cannot handle.
Signed-off-by: Shawn O. Pearce <sop@google.com>
2009-04-16 18:21:18 +00:00
|
|
|
for m in self._messages:
|
|
|
|
m.Print(self)
|
|
|
|
for m in self._failures:
|
|
|
|
m.Print(self)
|
|
|
|
|
|
|
|
self._messages = []
|
|
|
|
self._failures = []
|
|
|
|
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
class MetaProject(Project):
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
"""A special project housed under .repo.
|
|
|
|
"""
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def __init__(self, manifest, name, gitdir, worktree):
|
|
|
|
Project.__init__(self,
|
2014-07-16 11:56:40 +00:00
|
|
|
manifest=manifest,
|
|
|
|
name=name,
|
|
|
|
gitdir=gitdir,
|
|
|
|
objdir=gitdir,
|
|
|
|
worktree=worktree,
|
|
|
|
remote=RemoteSpec('origin'),
|
|
|
|
relpath='.repo/%s' % name,
|
|
|
|
revisionExpr='refs/heads/master',
|
|
|
|
revisionId=None,
|
|
|
|
groups=None)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
def PreSync(self):
|
|
|
|
if self.Exists:
|
|
|
|
cb = self.CurrentBranch
|
|
|
|
if cb:
|
|
|
|
base = self.GetBranch(cb).merge
|
|
|
|
if base:
|
2009-05-30 01:38:17 +00:00
|
|
|
self.revisionExpr = base
|
|
|
|
self.revisionId = None
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2017-07-10 21:46:25 +00:00
|
|
|
def MetaBranchSwitch(self, submodules=False):
|
2012-06-07 15:19:26 +00:00
|
|
|
""" Prepare MetaProject for manifest branch switch
|
|
|
|
"""
|
|
|
|
|
|
|
|
# detach and delete manifest branch, allowing a new
|
|
|
|
# branch to take over
|
2014-07-16 11:56:40 +00:00
|
|
|
syncbuf = SyncBuffer(self.config, detach_head=True)
|
2017-07-10 21:46:25 +00:00
|
|
|
self.Sync_LocalHalf(syncbuf, submodules=submodules)
|
2012-06-07 15:19:26 +00:00
|
|
|
syncbuf.Finish()
|
|
|
|
|
|
|
|
return GitCommand(self,
|
2016-02-10 17:44:30 +00:00
|
|
|
['update-ref', '-d', 'refs/heads/default'],
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True).Wait() == 0
|
2012-06-07 15:19:26 +00:00
|
|
|
|
2009-04-18 17:49:00 +00:00
|
|
|
@property
|
|
|
|
def LastFetch(self):
|
|
|
|
try:
|
|
|
|
fh = os.path.join(self.gitdir, 'FETCH_HEAD')
|
|
|
|
return os.path.getmtime(fh)
|
|
|
|
except OSError:
|
|
|
|
return 0
|
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
@property
|
|
|
|
def HasChanges(self):
|
|
|
|
"""Has the remote received new commits not yet checked out?
|
|
|
|
"""
|
2009-05-30 01:38:17 +00:00
|
|
|
if not self.remote or not self.revisionExpr:
|
2009-04-18 17:39:28 +00:00
|
|
|
return False
|
|
|
|
|
2012-09-24 03:15:13 +00:00
|
|
|
all_refs = self.bare_ref.all
|
|
|
|
revid = self.GetRevisionId(all_refs)
|
2009-04-18 17:39:28 +00:00
|
|
|
head = self.work_git.GetHead()
|
|
|
|
if head.startswith(R_HEADS):
|
|
|
|
try:
|
2012-09-24 03:15:13 +00:00
|
|
|
head = all_refs[head]
|
2009-04-18 17:39:28 +00:00
|
|
|
except KeyError:
|
|
|
|
head = None
|
|
|
|
|
|
|
|
if revid == head:
|
|
|
|
return False
|
2009-05-30 01:38:17 +00:00
|
|
|
elif self._revlist(not_rev(HEAD), revid):
|
2008-10-21 14:00:00 +00:00
|
|
|
return True
|
|
|
|
return False
|