mirror of
https://gerrit.googlesource.com/git-repo
synced 2024-12-21 07:16:21 +00:00
5fb9c6a5b3
This change reverts stable to v2.29.5, to fix clients that received v2.29.6, and keep future updates simpler. Change-Id: I2f5c52c466b7321665c9699ccdbf98f928483fee
311 lines
8.9 KiB
Python
311 lines
8.9 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
|
|
if gitdir:
|
|
# 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'] = gitdir + '/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))
|
|
|
|
if IsTrace():
|
|
global LAST_CWD
|
|
global LAST_GITDIR
|
|
|
|
dbg = ''
|
|
|
|
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'
|
|
Trace('%s', 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
|