mirror of
https://gerrit.googlesource.com/git-repo
synced 2024-12-21 07:16:21 +00:00
4aa8584ec6
If the user passes a bad --repo-rev setting in a new checkout, add a tip to the error message that their option is probably bad instead of just saying "unable to resolve". If the user has already initialized a checkout, we'd display a raw traceback which would confuse them. Swallow that and also include the --repo-rev tip. Bug: https://crbug.com/gerrit/15610 Change-Id: I5d72513c7b37bf9bb5d19862fcdfaf0d1f44e886 Reviewed-on: https://gerrit-review.googlesource.com/c/git-repo/+/328820 Reviewed-by: Jack Neus <jackneus@google.com> Tested-by: Mike Frysinger <vapier@google.com>
550 lines
20 KiB
Python
550 lines
20 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 os
|
|
import platform
|
|
import re
|
|
import sys
|
|
import urllib.parse
|
|
|
|
from color import Coloring
|
|
from command import InteractiveCommand, MirrorSafeCommand
|
|
from error import ManifestParseError
|
|
from project import SyncBuffer
|
|
from git_config import GitConfig
|
|
from git_command import git_require, MIN_GIT_VERSION_SOFT, MIN_GIT_VERSION_HARD
|
|
import fetch
|
|
import git_superproject
|
|
import platform_utils
|
|
from wrapper import Wrapper
|
|
|
|
|
|
class Init(InteractiveCommand, MirrorSafeCommand):
|
|
COMMON = True
|
|
helpSummary = "Initialize a repo client checkout in the current directory"
|
|
helpUsage = """
|
|
%prog [options] [manifest url]
|
|
"""
|
|
helpDescription = """
|
|
The '%prog' command is run once to install and initialize repo.
|
|
The latest repo source code and manifest collection is downloaded
|
|
from the server and is installed in the .repo/ directory in the
|
|
current working directory.
|
|
|
|
When creating a new checkout, the manifest URL is the only required setting.
|
|
It may be specified using the --manifest-url option, or as the first optional
|
|
argument.
|
|
|
|
The optional -b argument can be used to select the manifest branch
|
|
to checkout and use. If no branch is specified, the remote's default
|
|
branch is used. This is equivalent to using -b HEAD.
|
|
|
|
The optional -m argument can be used to specify an alternate manifest
|
|
to be used. If no manifest is specified, the manifest default.xml
|
|
will be used.
|
|
|
|
If the --standalone-manifest argument is set, the manifest will be downloaded
|
|
directly from the specified --manifest-url as a static file (rather than
|
|
setting up a manifest git checkout). With --standalone-manifest, the manifest
|
|
will be fully static and will not be re-downloaded during subsesquent
|
|
`repo init` and `repo sync` calls.
|
|
|
|
The --reference option can be used to point to a directory that
|
|
has the content of a --mirror sync. This will make the working
|
|
directory use as much data as possible from the local reference
|
|
directory when fetching from the server. This will make the sync
|
|
go a lot faster by reducing data traffic on the network.
|
|
|
|
The --dissociate option can be used to borrow the objects from
|
|
the directory specified with the --reference option only to reduce
|
|
network transfer, and stop borrowing from them after a first clone
|
|
is made by making necessary local copies of borrowed objects.
|
|
|
|
The --no-clone-bundle option disables any attempt to use
|
|
$URL/clone.bundle to bootstrap a new Git repository from a
|
|
resumeable bundle file on a content delivery network. This
|
|
may be necessary if there are problems with the local Python
|
|
HTTP client or proxy configuration, but the Git binary works.
|
|
|
|
# Switching Manifest Branches
|
|
|
|
To switch to another manifest branch, `repo init -b otherbranch`
|
|
may be used in an existing client. However, as this only updates the
|
|
manifest, a subsequent `repo sync` (or `repo sync -d`) is necessary
|
|
to update the working directory files.
|
|
"""
|
|
|
|
def _CommonOptions(self, p):
|
|
"""Disable due to re-use of Wrapper()."""
|
|
|
|
def _Options(self, p, gitc_init=False):
|
|
Wrapper().InitParser(p, gitc_init=gitc_init)
|
|
|
|
def _RegisteredEnvironmentOptions(self):
|
|
return {'REPO_MANIFEST_URL': 'manifest_url',
|
|
'REPO_MIRROR_LOCATION': 'reference'}
|
|
|
|
def _CloneSuperproject(self, opt):
|
|
"""Clone the superproject based on the superproject's url and branch.
|
|
|
|
Args:
|
|
opt: Program options returned from optparse. See _Options().
|
|
"""
|
|
superproject = git_superproject.Superproject(self.manifest,
|
|
self.repodir,
|
|
self.git_event_log,
|
|
quiet=opt.quiet)
|
|
sync_result = superproject.Sync()
|
|
if not sync_result.success:
|
|
print('warning: git update of superproject failed, repo sync will not '
|
|
'use superproject to fetch source; while this error is not fatal, '
|
|
'and you can continue to run repo sync, please run repo init with '
|
|
'the --no-use-superproject option to stop seeing this warning',
|
|
file=sys.stderr)
|
|
if sync_result.fatal and opt.use_superproject is not None:
|
|
sys.exit(1)
|
|
|
|
def _SyncManifest(self, opt):
|
|
m = self.manifest.manifestProject
|
|
is_new = not m.Exists
|
|
|
|
# If repo has already been initialized, we take -u with the absence of
|
|
# --standalone-manifest to mean "transition to a standard repo set up",
|
|
# which necessitates starting fresh.
|
|
# If --standalone-manifest is set, we always tear everything down and start
|
|
# anew.
|
|
if not is_new:
|
|
was_standalone_manifest = m.config.GetString('manifest.standalone')
|
|
if was_standalone_manifest and not opt.manifest_url:
|
|
print('fatal: repo was initialized with a standlone manifest, '
|
|
'cannot be re-initialized without --manifest-url/-u')
|
|
sys.exit(1)
|
|
|
|
if opt.standalone_manifest or (was_standalone_manifest and
|
|
opt.manifest_url):
|
|
m.config.ClearCache()
|
|
if m.gitdir and os.path.exists(m.gitdir):
|
|
platform_utils.rmtree(m.gitdir)
|
|
if m.worktree and os.path.exists(m.worktree):
|
|
platform_utils.rmtree(m.worktree)
|
|
|
|
is_new = not m.Exists
|
|
if is_new:
|
|
if not opt.manifest_url:
|
|
print('fatal: manifest url is required.', file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
if not opt.quiet:
|
|
print('Downloading manifest from %s' %
|
|
(GitConfig.ForUser().UrlInsteadOf(opt.manifest_url),),
|
|
file=sys.stderr)
|
|
|
|
# The manifest project object doesn't keep track of the path on the
|
|
# server where this git is located, so let's save that here.
|
|
mirrored_manifest_git = None
|
|
if opt.reference:
|
|
manifest_git_path = urllib.parse.urlparse(opt.manifest_url).path[1:]
|
|
mirrored_manifest_git = os.path.join(opt.reference, manifest_git_path)
|
|
if not mirrored_manifest_git.endswith(".git"):
|
|
mirrored_manifest_git += ".git"
|
|
if not os.path.exists(mirrored_manifest_git):
|
|
mirrored_manifest_git = os.path.join(opt.reference,
|
|
'.repo/manifests.git')
|
|
|
|
m._InitGitDir(mirror_git=mirrored_manifest_git)
|
|
|
|
# If standalone_manifest is set, mark the project as "standalone" -- we'll
|
|
# still do much of the manifests.git set up, but will avoid actual syncs to
|
|
# a remote.
|
|
standalone_manifest = False
|
|
if opt.standalone_manifest:
|
|
standalone_manifest = True
|
|
m.config.SetString('manifest.standalone', opt.manifest_url)
|
|
elif not opt.manifest_url and not opt.manifest_branch:
|
|
# If -u is set and --standalone-manifest is not, then we're not in
|
|
# standalone mode. Otherwise, use config to infer what we were in the last
|
|
# init.
|
|
standalone_manifest = bool(m.config.GetString('manifest.standalone'))
|
|
if not standalone_manifest:
|
|
m.config.SetString('manifest.standalone', None)
|
|
|
|
self._ConfigureDepth(opt)
|
|
|
|
# Set the remote URL before the remote branch as we might need it below.
|
|
if opt.manifest_url:
|
|
r = m.GetRemote(m.remote.name)
|
|
r.url = opt.manifest_url
|
|
r.ResetFetch()
|
|
r.Save()
|
|
|
|
if not standalone_manifest:
|
|
if opt.manifest_branch:
|
|
if opt.manifest_branch == 'HEAD':
|
|
opt.manifest_branch = m.ResolveRemoteHead()
|
|
if opt.manifest_branch is None:
|
|
print('fatal: unable to resolve HEAD', file=sys.stderr)
|
|
sys.exit(1)
|
|
m.revisionExpr = opt.manifest_branch
|
|
else:
|
|
if is_new:
|
|
default_branch = m.ResolveRemoteHead()
|
|
if default_branch is None:
|
|
# If the remote doesn't have HEAD configured, default to master.
|
|
default_branch = 'refs/heads/master'
|
|
m.revisionExpr = default_branch
|
|
else:
|
|
m.PreSync()
|
|
|
|
groups = re.split(r'[,\s]+', opt.groups)
|
|
all_platforms = ['linux', 'darwin', 'windows']
|
|
platformize = lambda x: 'platform-' + x
|
|
if opt.platform == 'auto':
|
|
if (not opt.mirror and
|
|
not m.config.GetString('repo.mirror') == 'true'):
|
|
groups.append(platformize(platform.system().lower()))
|
|
elif opt.platform == 'all':
|
|
groups.extend(map(platformize, all_platforms))
|
|
elif opt.platform in all_platforms:
|
|
groups.append(platformize(opt.platform))
|
|
elif opt.platform != 'none':
|
|
print('fatal: invalid platform flag', file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
groups = [x for x in groups if x]
|
|
groupstr = ','.join(groups)
|
|
if opt.platform == 'auto' and groupstr == self.manifest.GetDefaultGroupsStr():
|
|
groupstr = None
|
|
m.config.SetString('manifest.groups', groupstr)
|
|
|
|
if opt.reference:
|
|
m.config.SetString('repo.reference', opt.reference)
|
|
|
|
if opt.dissociate:
|
|
m.config.SetBoolean('repo.dissociate', opt.dissociate)
|
|
|
|
if opt.worktree:
|
|
if opt.mirror:
|
|
print('fatal: --mirror and --worktree are incompatible',
|
|
file=sys.stderr)
|
|
sys.exit(1)
|
|
if opt.submodules:
|
|
print('fatal: --submodules and --worktree are incompatible',
|
|
file=sys.stderr)
|
|
sys.exit(1)
|
|
m.config.SetBoolean('repo.worktree', opt.worktree)
|
|
if is_new:
|
|
m.use_git_worktrees = True
|
|
print('warning: --worktree is experimental!', file=sys.stderr)
|
|
|
|
if opt.archive:
|
|
if is_new:
|
|
m.config.SetBoolean('repo.archive', opt.archive)
|
|
else:
|
|
print('fatal: --archive is only supported when initializing a new '
|
|
'workspace.', file=sys.stderr)
|
|
print('Either delete the .repo folder in this workspace, or initialize '
|
|
'in another location.', file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
if opt.mirror:
|
|
if is_new:
|
|
m.config.SetBoolean('repo.mirror', opt.mirror)
|
|
else:
|
|
print('fatal: --mirror is only supported when initializing a new '
|
|
'workspace.', file=sys.stderr)
|
|
print('Either delete the .repo folder in this workspace, or initialize '
|
|
'in another location.', file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
if opt.partial_clone is not None:
|
|
if opt.mirror:
|
|
print('fatal: --mirror and --partial-clone are mutually exclusive',
|
|
file=sys.stderr)
|
|
sys.exit(1)
|
|
m.config.SetBoolean('repo.partialclone', opt.partial_clone)
|
|
if opt.clone_filter:
|
|
m.config.SetString('repo.clonefilter', opt.clone_filter)
|
|
elif m.config.GetBoolean('repo.partialclone'):
|
|
opt.clone_filter = m.config.GetString('repo.clonefilter')
|
|
else:
|
|
opt.clone_filter = None
|
|
|
|
if opt.partial_clone_exclude is not None:
|
|
m.config.SetString('repo.partialcloneexclude', opt.partial_clone_exclude)
|
|
|
|
if opt.clone_bundle is None:
|
|
opt.clone_bundle = False if opt.partial_clone else True
|
|
else:
|
|
m.config.SetBoolean('repo.clonebundle', opt.clone_bundle)
|
|
|
|
if opt.submodules:
|
|
m.config.SetBoolean('repo.submodules', opt.submodules)
|
|
|
|
if opt.use_superproject is not None:
|
|
m.config.SetBoolean('repo.superproject', opt.use_superproject)
|
|
|
|
if standalone_manifest:
|
|
if is_new:
|
|
manifest_name = 'default.xml'
|
|
manifest_data = fetch.fetch_file(opt.manifest_url, verbose=opt.verbose)
|
|
dest = os.path.join(m.worktree, manifest_name)
|
|
os.makedirs(os.path.dirname(dest), exist_ok=True)
|
|
with open(dest, 'wb') as f:
|
|
f.write(manifest_data)
|
|
return
|
|
|
|
if not m.Sync_NetworkHalf(is_new=is_new, quiet=opt.quiet, verbose=opt.verbose,
|
|
clone_bundle=opt.clone_bundle,
|
|
current_branch_only=opt.current_branch_only,
|
|
tags=opt.tags, submodules=opt.submodules,
|
|
clone_filter=opt.clone_filter,
|
|
partial_clone_exclude=self.manifest.PartialCloneExclude):
|
|
r = m.GetRemote(m.remote.name)
|
|
print('fatal: cannot obtain manifest %s' % r.url, file=sys.stderr)
|
|
|
|
# Better delete the manifest git dir if we created it; otherwise next
|
|
# time (when user fixes problems) we won't go through the "is_new" logic.
|
|
if is_new:
|
|
platform_utils.rmtree(m.gitdir)
|
|
sys.exit(1)
|
|
|
|
if opt.manifest_branch:
|
|
m.MetaBranchSwitch(submodules=opt.submodules)
|
|
|
|
syncbuf = SyncBuffer(m.config)
|
|
m.Sync_LocalHalf(syncbuf, submodules=opt.submodules)
|
|
syncbuf.Finish()
|
|
|
|
if is_new or m.CurrentBranch is None:
|
|
if not m.StartBranch('default'):
|
|
print('fatal: cannot create default in manifest', file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
def _LinkManifest(self, name):
|
|
if not name:
|
|
print('fatal: manifest name (-m) is required.', file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
try:
|
|
self.manifest.Link(name)
|
|
except ManifestParseError as e:
|
|
print("fatal: manifest '%s' not available" % name, file=sys.stderr)
|
|
print('fatal: %s' % str(e), file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
def _Prompt(self, prompt, value):
|
|
print('%-10s [%s]: ' % (prompt, value), end='')
|
|
# TODO: When we require Python 3, use flush=True w/print above.
|
|
sys.stdout.flush()
|
|
a = sys.stdin.readline().strip()
|
|
if a == '':
|
|
return value
|
|
return a
|
|
|
|
def _ShouldConfigureUser(self, opt):
|
|
gc = self.client.globalConfig
|
|
mp = self.manifest.manifestProject
|
|
|
|
# If we don't have local settings, get from global.
|
|
if not mp.config.Has('user.name') or not mp.config.Has('user.email'):
|
|
if not gc.Has('user.name') or not gc.Has('user.email'):
|
|
return True
|
|
|
|
mp.config.SetString('user.name', gc.GetString('user.name'))
|
|
mp.config.SetString('user.email', gc.GetString('user.email'))
|
|
|
|
if not opt.quiet:
|
|
print()
|
|
print('Your identity is: %s <%s>' % (mp.config.GetString('user.name'),
|
|
mp.config.GetString('user.email')))
|
|
print("If you want to change this, please re-run 'repo init' with --config-name")
|
|
return False
|
|
|
|
def _ConfigureUser(self, opt):
|
|
mp = self.manifest.manifestProject
|
|
|
|
while True:
|
|
if not opt.quiet:
|
|
print()
|
|
name = self._Prompt('Your Name', mp.UserName)
|
|
email = self._Prompt('Your Email', mp.UserEmail)
|
|
|
|
if not opt.quiet:
|
|
print()
|
|
print('Your identity is: %s <%s>' % (name, email))
|
|
print('is this correct [y/N]? ', end='')
|
|
# TODO: When we require Python 3, use flush=True w/print above.
|
|
sys.stdout.flush()
|
|
a = sys.stdin.readline().strip().lower()
|
|
if a in ('yes', 'y', 't', 'true'):
|
|
break
|
|
|
|
if name != mp.UserName:
|
|
mp.config.SetString('user.name', name)
|
|
if email != mp.UserEmail:
|
|
mp.config.SetString('user.email', email)
|
|
|
|
def _HasColorSet(self, gc):
|
|
for n in ['ui', 'diff', 'status']:
|
|
if gc.Has('color.%s' % n):
|
|
return True
|
|
return False
|
|
|
|
def _ConfigureColor(self):
|
|
gc = self.client.globalConfig
|
|
if self._HasColorSet(gc):
|
|
return
|
|
|
|
class _Test(Coloring):
|
|
def __init__(self):
|
|
Coloring.__init__(self, gc, 'test color display')
|
|
self._on = True
|
|
out = _Test()
|
|
|
|
print()
|
|
print("Testing colorized output (for 'repo diff', 'repo status'):")
|
|
|
|
for c in ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan']:
|
|
out.write(' ')
|
|
out.printer(fg=c)(' %-6s ', c)
|
|
out.write(' ')
|
|
out.printer(fg='white', bg='black')(' %s ' % 'white')
|
|
out.nl()
|
|
|
|
for c in ['bold', 'dim', 'ul', 'reverse']:
|
|
out.write(' ')
|
|
out.printer(fg='black', attr=c)(' %-6s ', c)
|
|
out.nl()
|
|
|
|
print('Enable color display in this user account (y/N)? ', end='')
|
|
# TODO: When we require Python 3, use flush=True w/print above.
|
|
sys.stdout.flush()
|
|
a = sys.stdin.readline().strip().lower()
|
|
if a in ('y', 'yes', 't', 'true', 'on'):
|
|
gc.SetString('color.ui', 'auto')
|
|
|
|
def _ConfigureDepth(self, opt):
|
|
"""Configure the depth we'll sync down.
|
|
|
|
Args:
|
|
opt: Options from optparse. We care about opt.depth.
|
|
"""
|
|
# Opt.depth will be non-None if user actually passed --depth to repo init.
|
|
if opt.depth is not None:
|
|
if opt.depth > 0:
|
|
# Positive values will set the depth.
|
|
depth = str(opt.depth)
|
|
else:
|
|
# Negative numbers will clear the depth; passing None to SetString
|
|
# will do that.
|
|
depth = None
|
|
|
|
# We store the depth in the main manifest project.
|
|
self.manifest.manifestProject.config.SetString('repo.depth', depth)
|
|
|
|
def _DisplayResult(self, opt):
|
|
if self.manifest.IsMirror:
|
|
init_type = 'mirror '
|
|
else:
|
|
init_type = ''
|
|
|
|
if not opt.quiet:
|
|
print()
|
|
print('repo %shas been initialized in %s' %
|
|
(init_type, self.manifest.topdir))
|
|
|
|
current_dir = os.getcwd()
|
|
if current_dir != self.manifest.topdir:
|
|
print('If this is not the directory in which you want to initialize '
|
|
'repo, please run:')
|
|
print(' rm -r %s/.repo' % self.manifest.topdir)
|
|
print('and try again.')
|
|
|
|
def ValidateOptions(self, opt, args):
|
|
if opt.reference:
|
|
opt.reference = os.path.expanduser(opt.reference)
|
|
|
|
# Check this here, else manifest will be tagged "not new" and init won't be
|
|
# possible anymore without removing the .repo/manifests directory.
|
|
if opt.mirror:
|
|
if opt.archive:
|
|
self.OptionParser.error('--mirror and --archive cannot be used '
|
|
'together.')
|
|
if opt.use_superproject is not None:
|
|
self.OptionParser.error('--mirror and --use-superproject cannot be '
|
|
'used together.')
|
|
|
|
if opt.standalone_manifest and (opt.manifest_branch or
|
|
opt.manifest_name != 'default.xml'):
|
|
self.OptionParser.error('--manifest-branch and --manifest-name cannot'
|
|
' be used with --standalone-manifest.')
|
|
|
|
if args:
|
|
if opt.manifest_url:
|
|
self.OptionParser.error(
|
|
'--manifest-url option and URL argument both specified: only use '
|
|
'one to select the manifest URL.')
|
|
|
|
opt.manifest_url = args.pop(0)
|
|
|
|
if args:
|
|
self.OptionParser.error('too many arguments to init')
|
|
|
|
def Execute(self, opt, args):
|
|
git_require(MIN_GIT_VERSION_HARD, fail=True)
|
|
if not git_require(MIN_GIT_VERSION_SOFT):
|
|
print('repo: warning: git-%s+ will soon be required; please upgrade your '
|
|
'version of git to maintain support.'
|
|
% ('.'.join(str(x) for x in MIN_GIT_VERSION_SOFT),),
|
|
file=sys.stderr)
|
|
|
|
rp = self.manifest.repoProject
|
|
|
|
# Handle new --repo-url requests.
|
|
if opt.repo_url:
|
|
remote = rp.GetRemote('origin')
|
|
remote.url = opt.repo_url
|
|
remote.Save()
|
|
|
|
# Handle new --repo-rev requests.
|
|
if opt.repo_rev:
|
|
wrapper = Wrapper()
|
|
try:
|
|
remote_ref, rev = wrapper.check_repo_rev(
|
|
rp.gitdir, opt.repo_rev, repo_verify=opt.repo_verify, quiet=opt.quiet)
|
|
except wrapper.CloneFailure:
|
|
print('fatal: double check your --repo-rev setting.', file=sys.stderr)
|
|
sys.exit(1)
|
|
branch = rp.GetBranch('default')
|
|
branch.merge = remote_ref
|
|
rp.work_git.reset('--hard', rev)
|
|
branch.Save()
|
|
|
|
if opt.worktree:
|
|
# Older versions of git supported worktree, but had dangerous gc bugs.
|
|
git_require((2, 15, 0), fail=True, msg='git gc worktree corruption')
|
|
|
|
self._SyncManifest(opt)
|
|
self._LinkManifest(opt.manifest_name)
|
|
|
|
if self.manifest.manifestProject.config.GetBoolean('repo.superproject'):
|
|
self._CloneSuperproject(opt)
|
|
|
|
if os.isatty(0) and os.isatty(1) and not self.manifest.IsMirror:
|
|
if opt.config_name or self._ShouldConfigureUser(opt):
|
|
self._ConfigureUser(opt)
|
|
self._ConfigureColor()
|
|
|
|
self._DisplayResult(opt)
|