mirror of
https://gerrit.googlesource.com/git-repo
synced 2024-12-21 07:16:21 +00:00
d3cadf1856
Due to symlink resolution git was treating this as two different directories even if the paths were the same. This mitigates the git core bug inside of repo (while the git core fix is being worked on). Bug: b/255376186 Bug: https://crbug.com/gerrit/16247 Change-Id: I12458ee04c307be916851dddd36231997bc8839e Reviewed-on: https://gerrit-review.googlesource.com/c/git-repo/+/351836 Tested-by: Sam Saccone <samccone@google.com> Reviewed-by: LaMont Jones <lamontjones@google.com>
312 lines
9.1 KiB
Python
312 lines
9.1 KiB
Python
# 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.
|
|
|
|
import functools
|
|
import os
|
|
import sys
|
|
import subprocess
|
|
|
|
from error import GitError
|
|
from git_refs import HEAD
|
|
import platform_utils
|
|
from repo_trace import REPO_TRACE, IsTrace, Trace
|
|
from wrapper import Wrapper
|
|
|
|
GIT = 'git'
|
|
# NB: These do not need to be kept in sync with the repo launcher script.
|
|
# These may be much newer as it allows the repo launcher to roll between
|
|
# different repo releases while source versions might require a newer git.
|
|
#
|
|
# The soft version is when we start warning users that the version is old and
|
|
# we'll be dropping support for it. We'll refuse to work with versions older
|
|
# than the hard version.
|
|
#
|
|
# git-1.7 is in (EOL) Ubuntu Precise. git-1.9 is in Ubuntu Trusty.
|
|
MIN_GIT_VERSION_SOFT = (1, 9, 1)
|
|
MIN_GIT_VERSION_HARD = (1, 7, 2)
|
|
GIT_DIR = 'GIT_DIR'
|
|
|
|
LAST_GITDIR = None
|
|
LAST_CWD = None
|
|
|
|
|
|
class _GitCall(object):
|
|
@functools.lru_cache(maxsize=None)
|
|
def version_tuple(self):
|
|
ret = Wrapper().ParseGitVersion()
|
|
if ret is None:
|
|
print('fatal: unable to detect git version', file=sys.stderr)
|
|
sys.exit(1)
|
|
return ret
|
|
|
|
def __getattr__(self, name):
|
|
name = name.replace('_', '-')
|
|
|
|
def fun(*cmdv):
|
|
command = [name]
|
|
command.extend(cmdv)
|
|
return GitCommand(None, command).Wait() == 0
|
|
return fun
|
|
|
|
|
|
git = _GitCall()
|
|
|
|
|
|
def RepoSourceVersion():
|
|
"""Return the version of the repo.git tree."""
|
|
ver = getattr(RepoSourceVersion, 'version', None)
|
|
|
|
# We avoid GitCommand so we don't run into circular deps -- GitCommand needs
|
|
# to initialize version info we provide.
|
|
if ver is None:
|
|
env = GitCommand._GetBasicEnv()
|
|
|
|
proj = os.path.dirname(os.path.abspath(__file__))
|
|
env[GIT_DIR] = os.path.join(proj, '.git')
|
|
result = subprocess.run([GIT, 'describe', HEAD], stdout=subprocess.PIPE,
|
|
stderr=subprocess.DEVNULL, encoding='utf-8',
|
|
env=env, check=False)
|
|
if result.returncode == 0:
|
|
ver = result.stdout.strip()
|
|
if ver.startswith('v'):
|
|
ver = ver[1:]
|
|
else:
|
|
ver = 'unknown'
|
|
setattr(RepoSourceVersion, 'version', ver)
|
|
|
|
return ver
|
|
|
|
|
|
class UserAgent(object):
|
|
"""Mange User-Agent settings when talking to external services
|
|
|
|
We follow the style as documented here:
|
|
https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent
|
|
"""
|
|
|
|
_os = None
|
|
_repo_ua = None
|
|
_git_ua = None
|
|
|
|
@property
|
|
def os(self):
|
|
"""The operating system name."""
|
|
if self._os is None:
|
|
os_name = sys.platform
|
|
if os_name.lower().startswith('linux'):
|
|
os_name = 'Linux'
|
|
elif os_name == 'win32':
|
|
os_name = 'Win32'
|
|
elif os_name == 'cygwin':
|
|
os_name = 'Cygwin'
|
|
elif os_name == 'darwin':
|
|
os_name = 'Darwin'
|
|
self._os = os_name
|
|
|
|
return self._os
|
|
|
|
@property
|
|
def repo(self):
|
|
"""The UA when connecting directly from repo."""
|
|
if self._repo_ua is None:
|
|
py_version = sys.version_info
|
|
self._repo_ua = 'git-repo/%s (%s) git/%s Python/%d.%d.%d' % (
|
|
RepoSourceVersion(),
|
|
self.os,
|
|
git.version_tuple().full,
|
|
py_version.major, py_version.minor, py_version.micro)
|
|
|
|
return self._repo_ua
|
|
|
|
@property
|
|
def git(self):
|
|
"""The UA when running git."""
|
|
if self._git_ua is None:
|
|
self._git_ua = 'git/%s (%s) git-repo/%s' % (
|
|
git.version_tuple().full,
|
|
self.os,
|
|
RepoSourceVersion())
|
|
|
|
return self._git_ua
|
|
|
|
|
|
user_agent = UserAgent()
|
|
|
|
|
|
def git_require(min_version, fail=False, msg=''):
|
|
git_version = git.version_tuple()
|
|
if min_version <= git_version:
|
|
return True
|
|
if fail:
|
|
need = '.'.join(map(str, min_version))
|
|
if msg:
|
|
msg = ' for ' + msg
|
|
print('fatal: git %s or later required%s' % (need, msg), file=sys.stderr)
|
|
sys.exit(1)
|
|
return False
|
|
|
|
|
|
class GitCommand(object):
|
|
"""Wrapper around a single git invocation."""
|
|
|
|
def __init__(self,
|
|
project,
|
|
cmdv,
|
|
bare=False,
|
|
input=None,
|
|
capture_stdout=False,
|
|
capture_stderr=False,
|
|
merge_output=False,
|
|
disable_editor=False,
|
|
ssh_proxy=None,
|
|
cwd=None,
|
|
gitdir=None,
|
|
objdir=None):
|
|
env = self._GetBasicEnv()
|
|
|
|
if disable_editor:
|
|
env['GIT_EDITOR'] = ':'
|
|
if ssh_proxy:
|
|
env['REPO_SSH_SOCK'] = ssh_proxy.sock()
|
|
env['GIT_SSH'] = ssh_proxy.proxy
|
|
env['GIT_SSH_VARIANT'] = 'ssh'
|
|
if 'http_proxy' in env and 'darwin' == sys.platform:
|
|
s = "'http.proxy=%s'" % (env['http_proxy'],)
|
|
p = env.get('GIT_CONFIG_PARAMETERS')
|
|
if p is not None:
|
|
s = p + ' ' + s
|
|
env['GIT_CONFIG_PARAMETERS'] = s
|
|
if 'GIT_ALLOW_PROTOCOL' not in env:
|
|
env['GIT_ALLOW_PROTOCOL'] = (
|
|
'file:git:http:https:ssh:persistent-http:persistent-https:sso:rpc')
|
|
env['GIT_HTTP_USER_AGENT'] = user_agent.git
|
|
|
|
if project:
|
|
if not cwd:
|
|
cwd = project.worktree
|
|
if not gitdir:
|
|
gitdir = project.gitdir
|
|
# Git on Windows wants its paths only using / for reliability.
|
|
if platform_utils.isWindows():
|
|
if objdir:
|
|
objdir = objdir.replace('\\', '/')
|
|
if gitdir:
|
|
gitdir = gitdir.replace('\\', '/')
|
|
|
|
if objdir:
|
|
# Set to the place we want to save the objects.
|
|
env['GIT_OBJECT_DIRECTORY'] = objdir
|
|
|
|
alt_objects = os.path.join(gitdir, 'objects') if gitdir else None
|
|
if alt_objects and os.path.realpath(alt_objects) != os.path.realpath(objdir):
|
|
# Allow git to search the original place in case of local or unique refs
|
|
# that git will attempt to resolve even if we aren't fetching them.
|
|
env['GIT_ALTERNATE_OBJECT_DIRECTORIES'] = alt_objects
|
|
|
|
command = [GIT]
|
|
if bare:
|
|
if gitdir:
|
|
env[GIT_DIR] = gitdir
|
|
cwd = None
|
|
command.append(cmdv[0])
|
|
# Need to use the --progress flag for fetch/clone so output will be
|
|
# displayed as by default git only does progress output if stderr is a TTY.
|
|
if sys.stderr.isatty() and cmdv[0] in ('fetch', 'clone'):
|
|
if '--progress' not in cmdv and '--quiet' not in cmdv:
|
|
command.append('--progress')
|
|
command.extend(cmdv[1:])
|
|
|
|
stdin = subprocess.PIPE if input else None
|
|
stdout = subprocess.PIPE if capture_stdout else None
|
|
stderr = (subprocess.STDOUT if merge_output else
|
|
(subprocess.PIPE if capture_stderr else None))
|
|
|
|
dbg = ''
|
|
if IsTrace():
|
|
global LAST_CWD
|
|
global LAST_GITDIR
|
|
|
|
if cwd and LAST_CWD != cwd:
|
|
if LAST_GITDIR or LAST_CWD:
|
|
dbg += '\n'
|
|
dbg += ': cd %s\n' % cwd
|
|
LAST_CWD = cwd
|
|
|
|
if GIT_DIR in env and LAST_GITDIR != env[GIT_DIR]:
|
|
if LAST_GITDIR or LAST_CWD:
|
|
dbg += '\n'
|
|
dbg += ': export GIT_DIR=%s\n' % env[GIT_DIR]
|
|
LAST_GITDIR = env[GIT_DIR]
|
|
|
|
if 'GIT_OBJECT_DIRECTORY' in env:
|
|
dbg += ': export GIT_OBJECT_DIRECTORY=%s\n' % env['GIT_OBJECT_DIRECTORY']
|
|
if 'GIT_ALTERNATE_OBJECT_DIRECTORIES' in env:
|
|
dbg += ': export GIT_ALTERNATE_OBJECT_DIRECTORIES=%s\n' % env['GIT_ALTERNATE_OBJECT_DIRECTORIES']
|
|
|
|
dbg += ': '
|
|
dbg += ' '.join(command)
|
|
if stdin == subprocess.PIPE:
|
|
dbg += ' 0<|'
|
|
if stdout == subprocess.PIPE:
|
|
dbg += ' 1>|'
|
|
if stderr == subprocess.PIPE:
|
|
dbg += ' 2>|'
|
|
elif stderr == subprocess.STDOUT:
|
|
dbg += ' 2>&1'
|
|
|
|
with Trace('git command %s %s with debug: %s', LAST_GITDIR, command, dbg):
|
|
try:
|
|
p = subprocess.Popen(command,
|
|
cwd=cwd,
|
|
env=env,
|
|
encoding='utf-8',
|
|
errors='backslashreplace',
|
|
stdin=stdin,
|
|
stdout=stdout,
|
|
stderr=stderr)
|
|
except Exception as e:
|
|
raise GitError('%s: %s' % (command[1], e))
|
|
|
|
if ssh_proxy:
|
|
ssh_proxy.add_client(p)
|
|
|
|
self.process = p
|
|
|
|
try:
|
|
self.stdout, self.stderr = p.communicate(input=input)
|
|
finally:
|
|
if ssh_proxy:
|
|
ssh_proxy.remove_client(p)
|
|
self.rc = p.wait()
|
|
|
|
@staticmethod
|
|
def _GetBasicEnv():
|
|
"""Return a basic env for running git under.
|
|
|
|
This is guaranteed to be side-effect free.
|
|
"""
|
|
env = os.environ.copy()
|
|
for key in (REPO_TRACE,
|
|
GIT_DIR,
|
|
'GIT_ALTERNATE_OBJECT_DIRECTORIES',
|
|
'GIT_OBJECT_DIRECTORY',
|
|
'GIT_WORK_TREE',
|
|
'GIT_GRAFT_FILE',
|
|
'GIT_INDEX_FILE'):
|
|
env.pop(key, None)
|
|
return env
|
|
|
|
def Wait(self):
|
|
return self.rc
|