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.
|
|
|
|
|
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
|
2008-10-21 14:00:00 +00:00
|
|
|
import os
|
2022-04-05 19:30:46 +00:00
|
|
|
import platform
|
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
|
2023-08-22 01:20:32 +00:00
|
|
|
from typing import List, NamedTuple
|
2019-06-13 06:24:21 +00:00
|
|
|
import urllib.parse
|
2011-10-11 21:05:21 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
from color import Coloring
|
2023-08-22 01:20:32 +00:00
|
|
|
from error import DownloadError
|
|
|
|
from error import GitError
|
|
|
|
from error import ManifestInvalidPathError
|
|
|
|
from error import ManifestInvalidRevisionError
|
|
|
|
from error import ManifestParseError
|
|
|
|
from error import NoManifestException
|
|
|
|
from error import RepoError
|
|
|
|
from error import UploadError
|
2022-04-21 17:18:35 +00:00
|
|
|
import fetch
|
2023-08-22 01:20:32 +00:00
|
|
|
from git_command import git_require
|
|
|
|
from git_command import GitCommand
|
|
|
|
from git_config import GetSchemeFromUrl
|
|
|
|
from git_config import GetUrlCookieFile
|
|
|
|
from git_config import GitConfig
|
|
|
|
from git_config import IsId
|
|
|
|
from git_refs import GitRefs
|
|
|
|
from git_refs import HEAD
|
|
|
|
from git_refs import R_HEADS
|
|
|
|
from git_refs import R_M
|
|
|
|
from git_refs import R_PUB
|
|
|
|
from git_refs import R_TAGS
|
|
|
|
from git_refs import R_WORKTREE_M
|
2022-06-01 21:03:34 +00:00
|
|
|
import git_superproject
|
2022-04-06 17:10:21 +00:00
|
|
|
from git_trace2_event_log import EventLog
|
2016-11-01 18:24:03 +00:00
|
|
|
import platform_utils
|
2019-08-26 19:22:36 +00:00
|
|
|
import progress
|
2023-09-14 08:17:20 +00:00
|
|
|
from repo_logging import RepoLogger
|
2022-11-03 20:51:19 +00:00
|
|
|
from repo_trace import Trace
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-09-14 08:17:20 +00:00
|
|
|
logger = RepoLogger(__file__)
|
|
|
|
|
|
|
|
|
2022-09-01 15:15:04 +00:00
|
|
|
class SyncNetworkHalfResult(NamedTuple):
|
2023-03-11 06:46:20 +00:00
|
|
|
"""Sync_NetworkHalf return value."""
|
|
|
|
|
|
|
|
# Did we query the remote? False when optimized_fetch is True and we have
|
|
|
|
# the commit already present.
|
|
|
|
remote_fetched: bool
|
2023-07-14 23:45:35 +00:00
|
|
|
# Error from SyncNetworkHalf
|
|
|
|
error: Exception = None
|
|
|
|
|
|
|
|
@property
|
|
|
|
def success(self) -> bool:
|
|
|
|
return not self.error
|
|
|
|
|
|
|
|
|
|
|
|
class SyncNetworkHalfError(RepoError):
|
|
|
|
"""Failure trying to sync."""
|
|
|
|
|
|
|
|
|
|
|
|
class DeleteWorktreeError(RepoError):
|
|
|
|
"""Failure to delete worktree."""
|
|
|
|
|
|
|
|
def __init__(
|
|
|
|
self, *args, aggregate_errors: List[Exception] = None, **kwargs
|
|
|
|
) -> None:
|
|
|
|
super().__init__(*args, **kwargs)
|
|
|
|
self.aggregate_errors = aggregate_errors or []
|
|
|
|
|
|
|
|
|
|
|
|
class DeleteDirtyWorktreeError(DeleteWorktreeError):
|
|
|
|
"""Failure to delete worktree due to uncommitted changes."""
|
2022-09-01 15:15:04 +00:00
|
|
|
|
2023-01-05 17:57:31 +00:00
|
|
|
|
2020-04-02 18:36:09 +00:00
|
|
|
# Maximum sleep time allowed during retries.
|
|
|
|
MAXIMUM_RETRY_SLEEP_SEC = 3600.0
|
|
|
|
# +-10% random jitter is added to each Fetches retry sleep duration.
|
|
|
|
RETRY_JITTER_PERCENT = 0.1
|
|
|
|
|
2022-11-02 22:01:29 +00:00
|
|
|
# Whether to use alternates. Switching back and forth is *NOT* supported.
|
2021-12-21 05:40:31 +00:00
|
|
|
# TODO(vapier): Remove knob once behavior is verified.
|
2023-03-11 06:46:20 +00:00
|
|
|
_ALTERNATES = os.environ.get("REPO_USE_ALTERNATES") == "1"
|
2020-04-02 18:36:09 +00:00
|
|
|
|
2023-01-05 17:57:31 +00:00
|
|
|
|
2009-04-18 21:45:51 +00:00
|
|
|
def _lwrite(path, content):
|
2023-03-11 06:46:20 +00:00
|
|
|
lock = "%s.lock" % path
|
2009-04-18 21:45:51 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
# Maintain Unix line endings on all OS's to match git behavior.
|
|
|
|
with open(lock, "w", newline="\n") as fd:
|
|
|
|
fd.write(content)
|
2009-04-18 21:45:51 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
try:
|
|
|
|
platform_utils.rename(lock, path)
|
|
|
|
except OSError:
|
|
|
|
platform_utils.remove(lock)
|
|
|
|
raise
|
2009-04-18 21:45:51 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2008-10-21 14:00:00 +00:00
|
|
|
def not_rev(r):
|
2023-03-11 06:46:20 +00:00
|
|
|
return "^" + r
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2009-01-06 00:18:58 +00:00
|
|
|
def sq(r):
|
2023-03-11 06:46:20 +00:00
|
|
|
return "'" + r.replace("'", "'''") + "'"
|
2008-11-03 18:32:09 +00:00
|
|
|
|
2020-02-12 06:20:19 +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():
|
2023-03-11 06:46:20 +00:00
|
|
|
"""List the hooks present in the 'hooks' directory.
|
2015-03-17 18:29:58 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
These hooks are project hooks and are copied to the '.git/hooks' directory
|
|
|
|
of all subprojects.
|
2015-03-17 18:29:58 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
This function caches the list of hooks (based on the contents of the
|
|
|
|
'repo/hooks' directory) on the first call.
|
2015-03-17 18:29:58 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
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:
|
|
|
|
d = platform_utils.realpath(os.path.abspath(os.path.dirname(__file__)))
|
|
|
|
d = os.path.join(d, "hooks")
|
|
|
|
_project_hook_list = [
|
|
|
|
os.path.join(d, x) for x in platform_utils.listdir(d)
|
|
|
|
]
|
|
|
|
return _project_hook_list
|
2015-03-17 18:29:58 +00:00
|
|
|
|
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class DownloadedChange:
|
2023-03-11 06:46:20 +00:00
|
|
|
_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:
|
|
|
|
self._commit_cache = self.project.bare_git.rev_list(
|
|
|
|
"--abbrev=8",
|
|
|
|
"--abbrev-commit",
|
|
|
|
"--pretty=oneline",
|
|
|
|
"--reverse",
|
|
|
|
"--date-order",
|
|
|
|
not_rev(self.base),
|
|
|
|
self.commit,
|
|
|
|
"--",
|
|
|
|
)
|
|
|
|
return self._commit_cache
|
2008-10-23 18:58:52 +00:00
|
|
|
|
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class ReviewableBranch:
|
2023-03-11 06:46:20 +00:00
|
|
|
_commit_cache = None
|
|
|
|
_base_exists = None
|
|
|
|
|
|
|
|
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:
|
|
|
|
args = (
|
|
|
|
"--abbrev=8",
|
|
|
|
"--abbrev-commit",
|
|
|
|
"--pretty=oneline",
|
|
|
|
"--reverse",
|
|
|
|
"--date-order",
|
|
|
|
not_rev(self.base),
|
|
|
|
R_HEADS + self.name,
|
|
|
|
"--",
|
|
|
|
)
|
|
|
|
try:
|
2023-09-27 18:34:43 +00:00
|
|
|
self._commit_cache = self.project.bare_git.rev_list(
|
|
|
|
*args, log_as_error=self.base_exists
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
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 = []
|
|
|
|
|
|
|
|
return self._commit_cache
|
|
|
|
|
|
|
|
@property
|
|
|
|
def unabbrev_commits(self):
|
|
|
|
r = dict()
|
|
|
|
for commit in self.project.bare_git.rev_list(
|
|
|
|
not_rev(self.base), R_HEADS + self.name, "--"
|
|
|
|
):
|
|
|
|
r[commit[0:8]] = commit
|
|
|
|
return r
|
|
|
|
|
|
|
|
@property
|
|
|
|
def date(self):
|
|
|
|
return self.project.bare_git.log(
|
|
|
|
"--pretty=format:%cd", "-n", "1", R_HEADS + self.name, "--"
|
|
|
|
)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
@property
|
|
|
|
def base_exists(self):
|
|
|
|
"""Whether the branch we're tracking exists.
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
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
|
|
|
|
|
|
|
|
def UploadForReview(
|
|
|
|
self,
|
|
|
|
people,
|
|
|
|
dryrun=False,
|
|
|
|
auto_topic=False,
|
|
|
|
hashtags=(),
|
|
|
|
labels=(),
|
|
|
|
private=False,
|
|
|
|
notify=None,
|
|
|
|
wip=False,
|
|
|
|
ready=False,
|
|
|
|
dest_branch=None,
|
|
|
|
validate_certs=True,
|
|
|
|
push_options=None,
|
|
|
|
):
|
|
|
|
self.project.UploadForReview(
|
|
|
|
branch=self.name,
|
|
|
|
people=people,
|
|
|
|
dryrun=dryrun,
|
|
|
|
auto_topic=auto_topic,
|
|
|
|
hashtags=hashtags,
|
|
|
|
labels=labels,
|
|
|
|
private=private,
|
|
|
|
notify=notify,
|
|
|
|
wip=wip,
|
|
|
|
ready=ready,
|
|
|
|
dest_branch=dest_branch,
|
|
|
|
validate_certs=validate_certs,
|
|
|
|
push_options=push_options,
|
|
|
|
)
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def GetPublishedRefs(self):
|
|
|
|
refs = {}
|
|
|
|
output = self.project.bare_git.ls_remote(
|
|
|
|
self.branch.remote.SshReviewUrl(self.project.UserEmail),
|
|
|
|
"refs/changes/*",
|
|
|
|
)
|
|
|
|
for line in output.split("\n"):
|
|
|
|
try:
|
|
|
|
(sha, ref) = line.split()
|
|
|
|
refs[sha] = ref
|
|
|
|
except ValueError:
|
|
|
|
pass
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
return refs
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
class StatusColoring(Coloring):
|
|
|
|
def __init__(self, config):
|
|
|
|
super().__init__(config, "status")
|
|
|
|
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")
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +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
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
class DiffColoring(Coloring):
|
|
|
|
def __init__(self, config):
|
|
|
|
super().__init__(config, "diff")
|
|
|
|
self.project = self.printer("header", attr="bold")
|
|
|
|
self.fail = self.printer("fail", fg="red")
|
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class Annotation:
|
2023-03-11 06:46:20 +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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def __eq__(self, other):
|
|
|
|
if not isinstance(other, Annotation):
|
|
|
|
return False
|
|
|
|
return self.__dict__ == other.__dict__
|
2021-07-20 20:52:33 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def __lt__(self, other):
|
|
|
|
# This exists just so that lists of Annotation objects can be sorted,
|
|
|
|
# for use in comparisons.
|
|
|
|
if not isinstance(other, Annotation):
|
|
|
|
raise ValueError("comparison is not between two Annotation objects")
|
|
|
|
if self.name == other.name:
|
|
|
|
if self.value == other.value:
|
|
|
|
return self.keep < other.keep
|
|
|
|
return self.value < other.value
|
|
|
|
return self.name < other.name
|
2021-07-20 20:52:33 +00:00
|
|
|
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2019-08-02 19:57:57 +00:00
|
|
|
def _SafeExpandPath(base, subpath, skipfinal=False):
|
2023-03-11 06:46:20 +00:00
|
|
|
"""Make sure |subpath| is completely safe under |base|.
|
|
|
|
|
|
|
|
We make sure no intermediate symlinks are traversed, and that the final path
|
|
|
|
is not a special file (e.g. not a socket or fifo).
|
|
|
|
|
|
|
|
NB: We rely on a number of paths already being filtered out while parsing
|
|
|
|
the manifest. See the validation logic in manifest_xml.py for more details.
|
|
|
|
"""
|
|
|
|
# Split up the path by its components. We can't use os.path.sep exclusively
|
|
|
|
# as some platforms (like Windows) will convert / to \ and that bypasses all
|
|
|
|
# our constructed logic here. Especially since manifest authors only use
|
|
|
|
# / in their paths.
|
|
|
|
resep = re.compile(r"[/%s]" % re.escape(os.path.sep))
|
|
|
|
components = resep.split(subpath)
|
|
|
|
if skipfinal:
|
|
|
|
# Whether the caller handles the final component itself.
|
|
|
|
finalpart = components.pop()
|
|
|
|
|
|
|
|
path = base
|
|
|
|
for part in components:
|
|
|
|
if part in {".", ".."}:
|
|
|
|
raise ManifestInvalidPathError(
|
2023-09-29 15:04:49 +00:00
|
|
|
f'{subpath}: "{part}" not allowed in paths'
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
path = os.path.join(path, part)
|
|
|
|
if platform_utils.islink(path):
|
|
|
|
raise ManifestInvalidPathError(
|
2023-09-29 15:04:49 +00:00
|
|
|
f"{path}: traversing symlinks not allow"
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
if os.path.exists(path):
|
|
|
|
if not os.path.isfile(path) and not platform_utils.isdir(path):
|
|
|
|
raise ManifestInvalidPathError(
|
2023-09-29 15:04:49 +00:00
|
|
|
f"{path}: only regular files & directories allowed"
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
if skipfinal:
|
|
|
|
path = os.path.join(path, finalpart)
|
|
|
|
|
|
|
|
return path
|
2019-08-02 19:57:57 +00:00
|
|
|
|
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class _CopyFile:
|
2023-03-11 06:46:20 +00:00
|
|
|
"""Container for <copyfile> manifest element."""
|
2019-08-02 19:57:57 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def __init__(self, git_worktree, src, topdir, dest):
|
|
|
|
"""Register a <copyfile> request.
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Args:
|
|
|
|
git_worktree: Absolute path to the git project checkout.
|
|
|
|
src: Relative path under |git_worktree| of file to read.
|
|
|
|
topdir: Absolute path to the top of the repo client checkout.
|
|
|
|
dest: Relative path under |topdir| of file to write.
|
|
|
|
"""
|
|
|
|
self.git_worktree = git_worktree
|
|
|
|
self.topdir = topdir
|
|
|
|
self.src = src
|
|
|
|
self.dest = dest
|
|
|
|
|
|
|
|
def _Copy(self):
|
|
|
|
src = _SafeExpandPath(self.git_worktree, self.src)
|
|
|
|
dest = _SafeExpandPath(self.topdir, self.dest)
|
|
|
|
|
|
|
|
if platform_utils.isdir(src):
|
|
|
|
raise ManifestInvalidPathError(
|
2023-09-29 15:04:49 +00:00
|
|
|
f"{self.src}: copying from directory not supported"
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
if platform_utils.isdir(dest):
|
|
|
|
raise ManifestInvalidPathError(
|
2023-09-29 15:04:49 +00:00
|
|
|
f"{self.dest}: copying to directory not allowed"
|
2023-03-11 06:46:20 +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):
|
|
|
|
platform_utils.remove(dest)
|
|
|
|
else:
|
|
|
|
dest_dir = os.path.dirname(dest)
|
|
|
|
if not platform_utils.isdir(dest_dir):
|
|
|
|
os.makedirs(dest_dir)
|
|
|
|
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)
|
2023-09-29 15:04:49 +00:00
|
|
|
except OSError:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("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
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class _LinkFile:
|
2023-03-11 06:46:20 +00:00
|
|
|
"""Container for <linkfile> manifest element."""
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def __init__(self, git_worktree, src, topdir, dest):
|
|
|
|
"""Register a <linkfile> request.
|
2019-08-02 19:57:57 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Args:
|
|
|
|
git_worktree: Absolute path to the git project checkout.
|
|
|
|
src: Target of symlink relative to path under |git_worktree|.
|
|
|
|
topdir: Absolute path to the top of the repo client checkout.
|
|
|
|
dest: Relative path under |topdir| of symlink to create.
|
|
|
|
"""
|
|
|
|
self.git_worktree = git_worktree
|
|
|
|
self.topdir = topdir
|
|
|
|
self.src = src
|
|
|
|
self.dest = dest
|
|
|
|
|
|
|
|
def __linkIt(self, relSrc, absDest):
|
|
|
|
# Link file if it does not exist or is out of date.
|
|
|
|
if not platform_utils.islink(absDest) or (
|
|
|
|
platform_utils.readlink(absDest) != relSrc
|
|
|
|
):
|
|
|
|
try:
|
|
|
|
# Remove existing file first, since it might be read-only.
|
|
|
|
if os.path.lexists(absDest):
|
|
|
|
platform_utils.remove(absDest)
|
|
|
|
else:
|
|
|
|
dest_dir = os.path.dirname(absDest)
|
|
|
|
if not platform_utils.isdir(dest_dir):
|
|
|
|
os.makedirs(dest_dir)
|
|
|
|
platform_utils.symlink(relSrc, absDest)
|
2023-09-29 15:04:49 +00:00
|
|
|
except OSError:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
|
|
|
"error: Cannot link file %s to %s", relSrc, absDest
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
def _Link(self):
|
|
|
|
"""Link the self.src & self.dest paths.
|
|
|
|
|
|
|
|
Handles wild cards on the src linking all of the files in the source in
|
|
|
|
to the destination directory.
|
|
|
|
"""
|
|
|
|
# Some people use src="." to create stable links to projects. Let's
|
|
|
|
# allow that but reject all other uses of "." to keep things simple.
|
|
|
|
if self.src == ".":
|
|
|
|
src = self.git_worktree
|
2014-04-21 22:10:59 +00:00
|
|
|
else:
|
2023-03-11 06:46:20 +00:00
|
|
|
src = _SafeExpandPath(self.git_worktree, self.src)
|
|
|
|
|
|
|
|
if not glob.has_magic(src):
|
|
|
|
# Entity does not contain a wild card so just a simple one to one
|
|
|
|
# link operation.
|
|
|
|
dest = _SafeExpandPath(self.topdir, self.dest, skipfinal=True)
|
|
|
|
# dest & src are absolute paths at this point. Make sure the target
|
|
|
|
# of the symlink is relative in the context of the repo client
|
|
|
|
# checkout.
|
|
|
|
relpath = os.path.relpath(src, os.path.dirname(dest))
|
|
|
|
self.__linkIt(relpath, dest)
|
|
|
|
else:
|
|
|
|
dest = _SafeExpandPath(self.topdir, self.dest)
|
|
|
|
# Entity contains a wild card.
|
|
|
|
if os.path.exists(dest) and not platform_utils.isdir(dest):
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
2023-03-11 06:46:20 +00:00
|
|
|
"Link error: src with wildcard, %s must be a directory",
|
|
|
|
dest,
|
|
|
|
)
|
|
|
|
else:
|
|
|
|
for absSrcFile in glob.glob(src):
|
|
|
|
# Create a releative path from source dir to destination
|
|
|
|
# dir.
|
|
|
|
absSrcDir = os.path.dirname(absSrcFile)
|
|
|
|
relSrcDir = os.path.relpath(absSrcDir, dest)
|
|
|
|
|
|
|
|
# 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 source.
|
|
|
|
absDest = os.path.join(dest, 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
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class RemoteSpec:
|
2023-03-11 06:46:20 +00:00
|
|
|
def __init__(
|
|
|
|
self,
|
|
|
|
name,
|
|
|
|
url=None,
|
|
|
|
pushUrl=None,
|
|
|
|
review=None,
|
|
|
|
revision=None,
|
|
|
|
orig_name=None,
|
|
|
|
fetchUrl=None,
|
|
|
|
):
|
|
|
|
self.name = name
|
|
|
|
self.url = url
|
|
|
|
self.pushUrl = pushUrl
|
|
|
|
self.review = review
|
|
|
|
self.revision = revision
|
|
|
|
self.orig_name = orig_name
|
|
|
|
self.fetchUrl = fetchUrl
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2021-02-05 18:06:18 +00:00
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class Project:
|
2023-03-11 06:46:20 +00:00
|
|
|
# These objects can be shared between several working trees.
|
|
|
|
@property
|
|
|
|
def shareable_dirs(self):
|
|
|
|
"""Return the shareable directories"""
|
|
|
|
if self.UseAlternates:
|
|
|
|
return ["hooks", "rr-cache"]
|
|
|
|
else:
|
|
|
|
return ["hooks", "objects", "rr-cache"]
|
|
|
|
|
|
|
|
def __init__(
|
|
|
|
self,
|
|
|
|
manifest,
|
|
|
|
name,
|
|
|
|
remote,
|
|
|
|
gitdir,
|
|
|
|
objdir,
|
|
|
|
worktree,
|
|
|
|
relpath,
|
|
|
|
revisionExpr,
|
|
|
|
revisionId,
|
|
|
|
rebase=True,
|
|
|
|
groups=None,
|
|
|
|
sync_c=False,
|
|
|
|
sync_s=False,
|
|
|
|
sync_tags=True,
|
|
|
|
clone_depth=None,
|
|
|
|
upstream=None,
|
|
|
|
parent=None,
|
|
|
|
use_git_worktrees=False,
|
|
|
|
is_derived=False,
|
|
|
|
dest_branch=None,
|
|
|
|
optimized_fetch=False,
|
|
|
|
retry_fetches=0,
|
|
|
|
old_revision=None,
|
|
|
|
):
|
|
|
|
"""Init a Project object.
|
2022-06-07 18:24:20 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
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.
|
|
|
|
objdir: Absolute path of directory to store git objects.
|
|
|
|
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.
|
|
|
|
sync_tags: The `sync-tags` attribute of manifest.xml's project
|
|
|
|
element.
|
|
|
|
upstream: The `upstream` attribute of manifest.xml's project
|
|
|
|
element.
|
|
|
|
parent: The parent Project object.
|
|
|
|
use_git_worktrees: Whether to use `git worktree` for this project.
|
|
|
|
is_derived: False if the project was explicitly defined in the
|
|
|
|
manifest; True if the project is a discovered submodule.
|
|
|
|
dest_branch: The branch to which to push changes for review by
|
|
|
|
default.
|
|
|
|
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.
|
|
|
|
retry_fetches: Retry remote fetches n times upon receiving transient
|
|
|
|
error with exponential backoff and jitter.
|
|
|
|
old_revision: saved git commit id for open GITC projects.
|
|
|
|
"""
|
|
|
|
self.client = self.manifest = manifest
|
|
|
|
self.name = name
|
|
|
|
self.remote = remote
|
|
|
|
self.UpdatePaths(relpath, worktree, gitdir, objdir)
|
|
|
|
self.SetRevision(revisionExpr, revisionId=revisionId)
|
|
|
|
|
|
|
|
self.rebase = rebase
|
|
|
|
self.groups = groups
|
|
|
|
self.sync_c = sync_c
|
|
|
|
self.sync_s = sync_s
|
|
|
|
self.sync_tags = sync_tags
|
|
|
|
self.clone_depth = clone_depth
|
|
|
|
self.upstream = upstream
|
|
|
|
self.parent = parent
|
|
|
|
# NB: Do not use this setting in __init__ to change behavior so that the
|
|
|
|
# manifest.git checkout can inspect & change it after instantiating.
|
|
|
|
# See the XmlManifest init code for more info.
|
|
|
|
self.use_git_worktrees = use_git_worktrees
|
|
|
|
self.is_derived = is_derived
|
|
|
|
self.optimized_fetch = optimized_fetch
|
|
|
|
self.retry_fetches = max(0, retry_fetches)
|
|
|
|
self.subprojects = []
|
|
|
|
|
|
|
|
self.snapshots = {}
|
|
|
|
self.copyfiles = []
|
|
|
|
self.linkfiles = []
|
|
|
|
self.annotations = []
|
|
|
|
self.dest_branch = dest_branch
|
|
|
|
self.old_revision = old_revision
|
|
|
|
|
|
|
|
# This will be filled in if a project is later identified to be the
|
|
|
|
# project containing repo hooks.
|
|
|
|
self.enabled_repo_hooks = []
|
|
|
|
|
|
|
|
def RelPath(self, local=True):
|
|
|
|
"""Return the path for the project relative to a manifest.
|
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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Args:
|
|
|
|
local: a boolean, if True, the path is relative to the local
|
|
|
|
(sub)manifest. If false, the path is relative to the outermost
|
|
|
|
manifest.
|
|
|
|
"""
|
|
|
|
if local:
|
|
|
|
return self.relpath
|
|
|
|
return os.path.join(self.manifest.path_prefix, self.relpath)
|
|
|
|
|
|
|
|
def SetRevision(self, revisionExpr, revisionId=None):
|
|
|
|
"""Set revisionId based on revision expression and id"""
|
|
|
|
self.revisionExpr = revisionExpr
|
|
|
|
if revisionId is None and revisionExpr and IsId(revisionExpr):
|
|
|
|
self.revisionId = self.revisionExpr
|
|
|
|
else:
|
|
|
|
self.revisionId = revisionId
|
|
|
|
|
|
|
|
def UpdatePaths(self, relpath, worktree, gitdir, objdir):
|
|
|
|
"""Update paths used by this project"""
|
|
|
|
self.gitdir = gitdir.replace("\\", "/")
|
|
|
|
self.objdir = objdir.replace("\\", "/")
|
|
|
|
if worktree:
|
|
|
|
self.worktree = os.path.normpath(worktree).replace("\\", "/")
|
|
|
|
else:
|
|
|
|
self.worktree = None
|
|
|
|
self.relpath = relpath
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
self.config = GitConfig.ForRepository(
|
|
|
|
gitdir=self.gitdir, defaults=self.manifest.globalConfig
|
|
|
|
)
|
2019-10-01 05:07:11 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if self.worktree:
|
|
|
|
self.work_git = self._GitGetByExec(
|
|
|
|
self, bare=False, gitdir=self.gitdir
|
|
|
|
)
|
|
|
|
else:
|
|
|
|
self.work_git = None
|
|
|
|
self.bare_git = self._GitGetByExec(self, bare=True, gitdir=self.gitdir)
|
|
|
|
self.bare_ref = GitRefs(self.gitdir)
|
|
|
|
self.bare_objdir = self._GitGetByExec(
|
|
|
|
self, bare=True, gitdir=self.objdir
|
|
|
|
)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
@property
|
|
|
|
def UseAlternates(self):
|
|
|
|
"""Whether git alternates are in use.
|
|
|
|
|
|
|
|
This will be removed once migration to alternates is complete.
|
|
|
|
"""
|
|
|
|
return _ALTERNATES or self.manifest.is_multimanifest
|
|
|
|
|
|
|
|
@property
|
|
|
|
def Derived(self):
|
|
|
|
return self.is_derived
|
|
|
|
|
|
|
|
@property
|
|
|
|
def Exists(self):
|
|
|
|
return platform_utils.isdir(self.gitdir) and platform_utils.isdir(
|
|
|
|
self.objdir
|
|
|
|
)
|
|
|
|
|
|
|
|
@property
|
|
|
|
def CurrentBranch(self):
|
|
|
|
"""Obtain the name of the currently checked out branch.
|
|
|
|
|
|
|
|
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).
|
|
|
|
"""
|
|
|
|
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
|
|
|
|
if b.startswith(R_HEADS):
|
|
|
|
return b[len(R_HEADS) :]
|
|
|
|
return None
|
|
|
|
|
|
|
|
def IsRebaseInProgress(self):
|
|
|
|
return (
|
|
|
|
os.path.exists(self.work_git.GetDotgitPath("rebase-apply"))
|
|
|
|
or os.path.exists(self.work_git.GetDotgitPath("rebase-merge"))
|
|
|
|
or os.path.exists(os.path.join(self.worktree, ".dotest"))
|
|
|
|
)
|
|
|
|
|
|
|
|
def IsDirty(self, consider_untracked=True):
|
|
|
|
"""Is the working directory modified in some way?"""
|
|
|
|
self.work_git.update_index(
|
|
|
|
"-q", "--unmerged", "--ignore-missing", "--refresh"
|
|
|
|
)
|
|
|
|
if self.work_git.DiffZ("diff-index", "-M", "--cached", HEAD):
|
|
|
|
return True
|
|
|
|
if self.work_git.DiffZ("diff-files"):
|
|
|
|
return True
|
|
|
|
if consider_untracked and self.UntrackedFiles():
|
|
|
|
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):
|
|
|
|
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 = ""
|
|
|
|
|
|
|
|
def GetRemote(self, name=None):
|
|
|
|
"""Get the configuration for a single remote.
|
|
|
|
|
|
|
|
Defaults to the current project's remote.
|
|
|
|
"""
|
|
|
|
if name is None:
|
|
|
|
name = self.remote.name
|
|
|
|
return self.config.GetRemote(name)
|
|
|
|
|
|
|
|
def GetBranch(self, name):
|
|
|
|
"""Get the configuration for a single branch."""
|
|
|
|
return self.config.GetBranch(name)
|
|
|
|
|
|
|
|
def GetBranches(self):
|
|
|
|
"""Get all existing local branches."""
|
|
|
|
current = self.CurrentBranch
|
|
|
|
all_refs = self._allrefs
|
|
|
|
heads = {}
|
|
|
|
|
|
|
|
for name, ref_id in all_refs.items():
|
|
|
|
if name.startswith(R_HEADS):
|
|
|
|
name = name[len(R_HEADS) :]
|
|
|
|
b = self.GetBranch(name)
|
|
|
|
b.current = name == current
|
|
|
|
b.published = None
|
|
|
|
b.revision = ref_id
|
|
|
|
heads[name] = b
|
|
|
|
|
|
|
|
for name, ref_id in all_refs.items():
|
|
|
|
if name.startswith(R_PUB):
|
|
|
|
name = name[len(R_PUB) :]
|
|
|
|
b = heads.get(name)
|
|
|
|
if b:
|
|
|
|
b.published = ref_id
|
|
|
|
|
|
|
|
return heads
|
|
|
|
|
|
|
|
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.
|
|
|
|
All projects are implicitly labelled with "all".
|
|
|
|
|
|
|
|
labels are resolved in order. In the example case of
|
|
|
|
project_groups: "all,group1,group2"
|
|
|
|
manifest_groups: "-group1,group2"
|
|
|
|
the project will be matched.
|
|
|
|
|
|
|
|
The special manifest group "default" will match any project that
|
|
|
|
does not have the special project group "notdefault"
|
|
|
|
"""
|
|
|
|
default_groups = self.manifest.default_groups or ["default"]
|
|
|
|
expanded_manifest_groups = manifest_groups or default_groups
|
|
|
|
expanded_project_groups = ["all"] + (self.groups or [])
|
|
|
|
if "notdefault" not in expanded_project_groups:
|
|
|
|
expanded_project_groups += ["default"]
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2012-04-16 17:36:08 +00:00
|
|
|
matched = False
|
2023-03-11 06:46:20 +00:00
|
|
|
for group in expanded_manifest_groups:
|
|
|
|
if group.startswith("-") and group[1:] in expanded_project_groups:
|
|
|
|
matched = False
|
|
|
|
elif group in expanded_project_groups:
|
|
|
|
matched = True
|
2012-04-16 17:36:08 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
return matched
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +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
|
|
|
|
2023-03-11 06:46:20 +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.
|
|
|
|
"""
|
|
|
|
details = []
|
|
|
|
self.work_git.update_index(
|
|
|
|
"-q", "--unmerged", "--ignore-missing", "--refresh"
|
|
|
|
)
|
|
|
|
if self.IsRebaseInProgress():
|
|
|
|
details.append("rebase in progress")
|
|
|
|
if not get_all:
|
|
|
|
return details
|
|
|
|
|
|
|
|
changes = self.work_git.DiffZ("diff-index", "--cached", HEAD).keys()
|
|
|
|
if changes:
|
|
|
|
details.extend(changes)
|
|
|
|
if not get_all:
|
|
|
|
return details
|
|
|
|
|
|
|
|
changes = self.work_git.DiffZ("diff-files").keys()
|
|
|
|
if changes:
|
|
|
|
details.extend(changes)
|
|
|
|
if not get_all:
|
|
|
|
return details
|
|
|
|
|
|
|
|
changes = self.UntrackedFiles()
|
|
|
|
if changes:
|
|
|
|
details.extend(changes)
|
2010-04-08 15:28:59 +00:00
|
|
|
|
2014-10-05 22:40:30 +00:00
|
|
|
return details
|
2010-04-08 15:28:59 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def UntrackedFiles(self):
|
|
|
|
"""Returns a list of strings, untracked files in the git tree."""
|
|
|
|
return self.work_git.LsOthers()
|
2010-04-08 15:28:59 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def HasChanges(self):
|
|
|
|
"""Returns true if there are uncommitted changes."""
|
|
|
|
return bool(self.UncommitedFiles(get_all=False))
|
2010-04-08 15:28:59 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def PrintWorkTreeStatus(self, output_redir=None, quiet=False, local=False):
|
|
|
|
"""Prints the status of the repository to stdout.
|
2014-10-05 22:40:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Args:
|
|
|
|
output_redir: If specified, redirect the output to this object.
|
|
|
|
quiet: If True then only print the project name. Do not print
|
|
|
|
the modified files, branch name, etc.
|
|
|
|
local: a boolean, if True, the path is relative to the local
|
|
|
|
(sub)manifest. If false, the path is relative to the outermost
|
|
|
|
manifest.
|
|
|
|
"""
|
|
|
|
if not platform_utils.isdir(self.worktree):
|
|
|
|
if output_redir is None:
|
|
|
|
output_redir = sys.stdout
|
|
|
|
print(file=output_redir)
|
|
|
|
print("project %s/" % self.RelPath(local), file=output_redir)
|
|
|
|
print(' missing (run "repo sync")', file=output_redir)
|
|
|
|
return
|
|
|
|
|
|
|
|
self.work_git.update_index(
|
|
|
|
"-q", "--unmerged", "--ignore-missing", "--refresh"
|
|
|
|
)
|
|
|
|
rb = self.IsRebaseInProgress()
|
|
|
|
di = self.work_git.DiffZ("diff-index", "-M", "--cached", HEAD)
|
|
|
|
df = self.work_git.DiffZ("diff-files")
|
|
|
|
do = self.work_git.LsOthers()
|
|
|
|
if not rb and not di and not df and not do and not self.CurrentBranch:
|
|
|
|
return "CLEAN"
|
|
|
|
|
|
|
|
out = StatusColoring(self.config)
|
|
|
|
if output_redir is not None:
|
|
|
|
out.redirect(output_redir)
|
|
|
|
out.project("project %-40s", self.RelPath(local) + "/ ")
|
|
|
|
|
|
|
|
if quiet:
|
|
|
|
out.nl()
|
|
|
|
return "DIRTY"
|
|
|
|
|
|
|
|
branch = self.CurrentBranch
|
|
|
|
if branch is None:
|
|
|
|
out.nobranch("(*** NO BRANCH ***)")
|
|
|
|
else:
|
|
|
|
out.branch("branch %s", branch)
|
|
|
|
out.nl()
|
2022-07-08 08:50:10 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if rb:
|
|
|
|
out.important("prior sync failed; rebase still in progress")
|
|
|
|
out.nl()
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
paths = list()
|
|
|
|
paths.extend(di.keys())
|
|
|
|
paths.extend(df.keys())
|
|
|
|
paths.extend(do)
|
2013-10-16 09:02:35 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
for p in sorted(set(paths)):
|
|
|
|
try:
|
|
|
|
i = di[p]
|
|
|
|
except KeyError:
|
|
|
|
i = None
|
2014-01-09 15:21:37 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
try:
|
|
|
|
f = df[p]
|
|
|
|
except KeyError:
|
|
|
|
f = None
|
|
|
|
|
|
|
|
if i:
|
|
|
|
i_status = i.status.upper()
|
|
|
|
else:
|
|
|
|
i_status = "-"
|
|
|
|
|
|
|
|
if f:
|
|
|
|
f_status = f.status.lower()
|
|
|
|
else:
|
|
|
|
f_status = "-"
|
|
|
|
|
|
|
|
if i and i.src_path:
|
2023-09-29 15:04:49 +00:00
|
|
|
line = " {}{}\t{} => {} ({}%)".format(
|
2023-03-11 06:46:20 +00:00
|
|
|
i_status,
|
|
|
|
f_status,
|
|
|
|
i.src_path,
|
|
|
|
p,
|
|
|
|
i.level,
|
|
|
|
)
|
|
|
|
else:
|
2023-09-29 15:04:49 +00:00
|
|
|
line = f" {i_status}{f_status}\t{p}"
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
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()
|
|
|
|
|
|
|
|
return "DIRTY"
|
|
|
|
|
|
|
|
def PrintWorkTreeDiff(
|
|
|
|
self, absolute_paths=False, output_redir=None, local=False
|
|
|
|
):
|
|
|
|
"""Prints the status of the repository to stdout."""
|
|
|
|
out = DiffColoring(self.config)
|
|
|
|
if output_redir:
|
|
|
|
out.redirect(output_redir)
|
|
|
|
cmd = ["diff"]
|
|
|
|
if out.is_on:
|
|
|
|
cmd.append("--color")
|
|
|
|
cmd.append(HEAD)
|
|
|
|
if absolute_paths:
|
|
|
|
cmd.append("--src-prefix=a/%s/" % self.RelPath(local))
|
|
|
|
cmd.append("--dst-prefix=b/%s/" % self.RelPath(local))
|
|
|
|
cmd.append("--")
|
|
|
|
try:
|
|
|
|
p = GitCommand(self, cmd, capture_stdout=True, capture_stderr=True)
|
|
|
|
p.Wait()
|
|
|
|
except GitError as e:
|
|
|
|
out.nl()
|
|
|
|
out.project("project %s/" % self.RelPath(local))
|
|
|
|
out.nl()
|
|
|
|
out.fail("%s", str(e))
|
|
|
|
out.nl()
|
|
|
|
return False
|
|
|
|
if p.stdout:
|
|
|
|
out.nl()
|
|
|
|
out.project("project %s/" % self.RelPath(local))
|
|
|
|
out.nl()
|
|
|
|
out.write("%s", p.stdout)
|
|
|
|
return p.Wait() == 0
|
|
|
|
|
|
|
|
def WasPublished(self, branch, all_refs=None):
|
|
|
|
"""Was the branch published (uploaded) for code review?
|
|
|
|
If so, returns the SHA-1 hash of the last published
|
|
|
|
state for the branch.
|
|
|
|
"""
|
|
|
|
key = R_PUB + branch
|
|
|
|
if all_refs is None:
|
|
|
|
try:
|
|
|
|
return self.bare_git.rev_parse(key)
|
|
|
|
except GitError:
|
|
|
|
return None
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
return all_refs[key]
|
|
|
|
except KeyError:
|
|
|
|
return None
|
|
|
|
|
|
|
|
def CleanPublishedCache(self, all_refs=None):
|
|
|
|
"""Prunes any stale published refs."""
|
|
|
|
if all_refs is None:
|
|
|
|
all_refs = self._allrefs
|
|
|
|
heads = set()
|
|
|
|
canrm = {}
|
|
|
|
for name, ref_id in all_refs.items():
|
|
|
|
if name.startswith(R_HEADS):
|
|
|
|
heads.add(name)
|
|
|
|
elif name.startswith(R_PUB):
|
|
|
|
canrm[name] = ref_id
|
|
|
|
|
|
|
|
for name, ref_id in canrm.items():
|
|
|
|
n = name[len(R_PUB) :]
|
|
|
|
if R_HEADS + n not in heads:
|
|
|
|
self.bare_git.DeleteRef(name, ref_id)
|
|
|
|
|
|
|
|
def GetUploadableBranches(self, selected_branch=None):
|
|
|
|
"""List any branches which can be uploaded for review."""
|
|
|
|
heads = {}
|
|
|
|
pubed = {}
|
|
|
|
|
|
|
|
for name, ref_id in self._allrefs.items():
|
|
|
|
if name.startswith(R_HEADS):
|
|
|
|
heads[name[len(R_HEADS) :]] = ref_id
|
|
|
|
elif name.startswith(R_PUB):
|
|
|
|
pubed[name[len(R_PUB) :]] = ref_id
|
|
|
|
|
|
|
|
ready = []
|
|
|
|
for branch, ref_id in heads.items():
|
|
|
|
if branch in pubed and pubed[branch] == ref_id:
|
|
|
|
continue
|
|
|
|
if selected_branch and branch != selected_branch:
|
|
|
|
continue
|
|
|
|
|
|
|
|
rb = self.GetUploadableBranch(branch)
|
|
|
|
if rb:
|
|
|
|
ready.append(rb)
|
|
|
|
return ready
|
|
|
|
|
|
|
|
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
|
2014-01-09 15:21:37 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def UploadForReview(
|
|
|
|
self,
|
|
|
|
branch=None,
|
|
|
|
people=([], []),
|
|
|
|
dryrun=False,
|
|
|
|
auto_topic=False,
|
|
|
|
hashtags=(),
|
|
|
|
labels=(),
|
|
|
|
private=False,
|
|
|
|
notify=None,
|
|
|
|
wip=False,
|
|
|
|
ready=False,
|
|
|
|
dest_branch=None,
|
|
|
|
validate_certs=True,
|
|
|
|
push_options=None,
|
|
|
|
):
|
|
|
|
"""Uploads the named branch for code review."""
|
|
|
|
if branch is None:
|
|
|
|
branch = self.CurrentBranch
|
|
|
|
if branch is None:
|
2023-07-14 23:45:35 +00:00
|
|
|
raise GitError("not currently on a branch", project=self.name)
|
2014-01-09 15:21:37 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
branch = self.GetBranch(branch)
|
|
|
|
if not branch.LocalMerge:
|
2023-07-14 23:45:35 +00:00
|
|
|
raise GitError(
|
|
|
|
"branch %s does not track a remote" % branch.name,
|
|
|
|
project=self.name,
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
if not branch.remote.review:
|
2023-07-14 23:45:35 +00:00
|
|
|
raise GitError(
|
|
|
|
"remote %s has no review url" % branch.remote.name,
|
|
|
|
project=self.name,
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
# Basic validity check on label syntax.
|
|
|
|
for label in labels:
|
|
|
|
if not re.match(r"^.+[+-][0-9]+$", label):
|
|
|
|
raise UploadError(
|
|
|
|
f'invalid label syntax "{label}": labels use forms like '
|
2023-08-17 18:36:41 +00:00
|
|
|
"CodeReview+1 or Verified-1",
|
|
|
|
project=self.name,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
if dest_branch is None:
|
|
|
|
dest_branch = self.dest_branch
|
|
|
|
if dest_branch is None:
|
|
|
|
dest_branch = branch.merge
|
|
|
|
if not dest_branch.startswith(R_HEADS):
|
|
|
|
dest_branch = R_HEADS + dest_branch
|
|
|
|
|
|
|
|
if not branch.remote.projectname:
|
|
|
|
branch.remote.projectname = self.name
|
|
|
|
branch.remote.Save()
|
|
|
|
|
|
|
|
url = branch.remote.ReviewUrl(self.UserEmail, validate_certs)
|
|
|
|
if url is None:
|
2023-08-17 18:36:41 +00:00
|
|
|
raise UploadError("review not configured", project=self.name)
|
2023-10-06 00:40:25 +00:00
|
|
|
cmd = ["push", "--progress"]
|
2023-03-11 06:46:20 +00:00
|
|
|
if dryrun:
|
|
|
|
cmd.append("-n")
|
|
|
|
|
|
|
|
if url.startswith("ssh://"):
|
|
|
|
cmd.append("--receive-pack=gerrit receive-pack")
|
|
|
|
|
2023-04-04 23:44:37 +00:00
|
|
|
# This stops git from pushing all reachable annotated tags when
|
|
|
|
# push.followTags is configured. Gerrit does not accept any tags
|
|
|
|
# pushed to a CL.
|
|
|
|
if git_require((1, 8, 3)):
|
|
|
|
cmd.append("--no-follow-tags")
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
for push_option in push_options or []:
|
|
|
|
cmd.append("-o")
|
|
|
|
cmd.append(push_option)
|
|
|
|
|
|
|
|
cmd.append(url)
|
|
|
|
|
|
|
|
if dest_branch.startswith(R_HEADS):
|
|
|
|
dest_branch = dest_branch[len(R_HEADS) :]
|
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
ref_spec = f"{R_HEADS + branch.name}:refs/for/{dest_branch}"
|
2023-03-11 06:46:20 +00:00
|
|
|
opts = []
|
|
|
|
if auto_topic:
|
|
|
|
opts += ["topic=" + branch.name]
|
|
|
|
opts += ["t=%s" % p for p in hashtags]
|
|
|
|
# NB: No need to encode labels as they've been validated above.
|
|
|
|
opts += ["l=%s" % p for p in labels]
|
|
|
|
|
|
|
|
opts += ["r=%s" % p for p in people[0]]
|
|
|
|
opts += ["cc=%s" % p for p in people[1]]
|
|
|
|
if notify:
|
|
|
|
opts += ["notify=" + notify]
|
|
|
|
if private:
|
|
|
|
opts += ["private"]
|
|
|
|
if wip:
|
|
|
|
opts += ["wip"]
|
|
|
|
if ready:
|
|
|
|
opts += ["ready"]
|
|
|
|
if opts:
|
|
|
|
ref_spec = ref_spec + "%" + ",".join(opts)
|
|
|
|
cmd.append(ref_spec)
|
|
|
|
|
2023-08-25 17:31:04 +00:00
|
|
|
GitCommand(self, cmd, bare=True, verify_command=True).Wait()
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
if not dryrun:
|
2023-09-29 15:04:49 +00:00
|
|
|
msg = "posted to {} for {}".format(
|
|
|
|
branch.remote.review, dest_branch
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
self.bare_git.UpdateRef(
|
|
|
|
R_PUB + branch.name, R_HEADS + branch.name, message=msg
|
|
|
|
)
|
|
|
|
|
|
|
|
def _ExtractArchive(self, tarpath, path=None):
|
|
|
|
"""Extract the given tar on its current location
|
2009-05-30 01:38:17 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Args:
|
|
|
|
tarpath: The path to the actual tar file
|
2009-05-30 01:38:17 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
"""
|
|
|
|
try:
|
|
|
|
with tarfile.open(tarpath, "r") as tar:
|
|
|
|
tar.extractall(path=path)
|
|
|
|
return True
|
2023-09-29 15:04:49 +00:00
|
|
|
except (OSError, tarfile.TarError) as e:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("error: Cannot extract archive %s: %s", tarpath, e)
|
2023-03-11 06:46:20 +00:00
|
|
|
return False
|
2009-05-30 01:38:17 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def Sync_NetworkHalf(
|
|
|
|
self,
|
|
|
|
quiet=False,
|
|
|
|
verbose=False,
|
|
|
|
output_redir=None,
|
|
|
|
is_new=None,
|
|
|
|
current_branch_only=None,
|
|
|
|
force_sync=False,
|
|
|
|
clone_bundle=True,
|
|
|
|
tags=None,
|
|
|
|
archive=False,
|
|
|
|
optimized_fetch=False,
|
|
|
|
retry_fetches=0,
|
|
|
|
prune=False,
|
|
|
|
submodules=False,
|
|
|
|
ssh_proxy=None,
|
|
|
|
clone_filter=None,
|
|
|
|
partial_clone_exclude=set(),
|
2023-05-23 20:06:55 +00:00
|
|
|
clone_filter_for_depth=None,
|
2023-03-11 06:46:20 +00:00
|
|
|
):
|
|
|
|
"""Perform only the network IO portion of the sync process.
|
|
|
|
Local working directory/branch state is not affected.
|
|
|
|
"""
|
|
|
|
if archive and not isinstance(self, MetaProject):
|
|
|
|
if self.remote.url.startswith(("http://", "https://")):
|
2023-07-14 23:45:35 +00:00
|
|
|
msg_template = (
|
|
|
|
"%s: Cannot fetch archives from http/https remotes."
|
|
|
|
)
|
|
|
|
msg_args = self.name
|
|
|
|
msg = msg_template % msg_args
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(msg_template, msg_args)
|
2023-07-14 23:45:35 +00:00
|
|
|
return SyncNetworkHalfResult(
|
|
|
|
False, SyncNetworkHalfError(msg, project=self.name)
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
name = self.relpath.replace("\\", "/")
|
|
|
|
name = name.replace("/", "_")
|
|
|
|
tarpath = "%s.tar" % name
|
|
|
|
topdir = self.manifest.topdir
|
2009-05-30 01:38:17 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
try:
|
|
|
|
self._FetchArchive(tarpath, cwd=topdir)
|
|
|
|
except GitError as e:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("error: %s", e)
|
2023-07-14 23:45:35 +00:00
|
|
|
return SyncNetworkHalfResult(False, e)
|
2021-04-29 08:50:38 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
# From now on, we only need absolute tarpath.
|
|
|
|
tarpath = os.path.join(topdir, tarpath)
|
2021-01-15 03:17:50 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if not self._ExtractArchive(tarpath, path=topdir):
|
2023-07-14 23:45:35 +00:00
|
|
|
return SyncNetworkHalfResult(
|
|
|
|
True,
|
|
|
|
SyncNetworkHalfError(
|
|
|
|
f"Unable to Extract Archive {tarpath}",
|
|
|
|
project=self.name,
|
|
|
|
),
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
try:
|
|
|
|
platform_utils.remove(tarpath)
|
|
|
|
except OSError as e:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.warn("warn: Cannot remove archive %s: %s", tarpath, e)
|
2023-03-11 06:46:20 +00:00
|
|
|
self._CopyAndLinkFiles()
|
2023-07-14 23:45:35 +00:00
|
|
|
return SyncNetworkHalfResult(True)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
# If the shared object dir already exists, don't try to rebootstrap with
|
|
|
|
# a clone bundle download. We should have the majority of objects
|
|
|
|
# already.
|
|
|
|
if clone_bundle and os.path.exists(self.objdir):
|
|
|
|
clone_bundle = False
|
|
|
|
|
|
|
|
if self.name in partial_clone_exclude:
|
|
|
|
clone_bundle = True
|
|
|
|
clone_filter = None
|
|
|
|
|
|
|
|
if is_new is None:
|
|
|
|
is_new = not self.Exists
|
|
|
|
if is_new:
|
|
|
|
self._InitGitDir(force_sync=force_sync, quiet=quiet)
|
|
|
|
else:
|
|
|
|
self._UpdateHooks(quiet=quiet)
|
|
|
|
self._InitRemote()
|
|
|
|
|
|
|
|
if self.UseAlternates:
|
|
|
|
# If gitdir/objects is a symlink, migrate it from the old layout.
|
|
|
|
gitdir_objects = os.path.join(self.gitdir, "objects")
|
|
|
|
if platform_utils.islink(gitdir_objects):
|
|
|
|
platform_utils.remove(gitdir_objects, missing_ok=True)
|
|
|
|
gitdir_alt = os.path.join(self.gitdir, "objects/info/alternates")
|
|
|
|
if not os.path.exists(gitdir_alt):
|
|
|
|
os.makedirs(os.path.dirname(gitdir_alt), exist_ok=True)
|
|
|
|
_lwrite(
|
|
|
|
gitdir_alt,
|
|
|
|
os.path.join(
|
|
|
|
os.path.relpath(self.objdir, gitdir_objects), "objects"
|
|
|
|
)
|
|
|
|
+ "\n",
|
|
|
|
)
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if is_new:
|
|
|
|
alt = os.path.join(self.objdir, "objects/info/alternates")
|
|
|
|
try:
|
|
|
|
with open(alt) as fd:
|
|
|
|
# This works for both absolute and relative alternate
|
|
|
|
# directories.
|
|
|
|
alt_dir = os.path.join(
|
|
|
|
self.objdir, "objects", fd.readline().rstrip()
|
|
|
|
)
|
2023-09-29 15:04:49 +00:00
|
|
|
except OSError:
|
2023-03-11 06:46:20 +00:00
|
|
|
alt_dir = None
|
|
|
|
else:
|
|
|
|
alt_dir = None
|
2019-09-23 21:42:23 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if (
|
|
|
|
clone_bundle
|
|
|
|
and alt_dir is None
|
|
|
|
and self._ApplyCloneBundle(
|
|
|
|
initial=is_new, quiet=quiet, verbose=verbose
|
|
|
|
)
|
|
|
|
):
|
|
|
|
is_new = False
|
|
|
|
|
|
|
|
if current_branch_only is None:
|
|
|
|
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
|
|
|
|
|
|
|
|
if tags is None:
|
|
|
|
tags = self.sync_tags
|
|
|
|
|
|
|
|
if self.clone_depth:
|
|
|
|
depth = self.clone_depth
|
|
|
|
else:
|
|
|
|
depth = self.manifest.manifestProject.depth
|
|
|
|
|
2023-05-23 20:06:55 +00:00
|
|
|
if depth and clone_filter_for_depth:
|
|
|
|
depth = None
|
|
|
|
clone_filter = clone_filter_for_depth
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
# See if we can skip the network fetch entirely.
|
|
|
|
remote_fetched = False
|
|
|
|
if not (
|
|
|
|
optimized_fetch
|
2023-09-11 11:38:00 +00:00
|
|
|
and IsId(self.revisionExpr)
|
|
|
|
and self._CheckForImmutableRevision()
|
2023-03-11 06:46:20 +00:00
|
|
|
):
|
|
|
|
remote_fetched = True
|
2023-07-14 23:45:35 +00:00
|
|
|
try:
|
|
|
|
if not self._RemoteFetch(
|
|
|
|
initial=is_new,
|
|
|
|
quiet=quiet,
|
|
|
|
verbose=verbose,
|
|
|
|
output_redir=output_redir,
|
|
|
|
alt_dir=alt_dir,
|
|
|
|
current_branch_only=current_branch_only,
|
|
|
|
tags=tags,
|
|
|
|
prune=prune,
|
|
|
|
depth=depth,
|
|
|
|
submodules=submodules,
|
|
|
|
force_sync=force_sync,
|
|
|
|
ssh_proxy=ssh_proxy,
|
|
|
|
clone_filter=clone_filter,
|
|
|
|
retry_fetches=retry_fetches,
|
|
|
|
):
|
|
|
|
return SyncNetworkHalfResult(
|
|
|
|
remote_fetched,
|
|
|
|
SyncNetworkHalfError(
|
|
|
|
f"Unable to remote fetch project {self.name}",
|
|
|
|
project=self.name,
|
|
|
|
),
|
|
|
|
)
|
|
|
|
except RepoError as e:
|
|
|
|
return SyncNetworkHalfResult(
|
|
|
|
remote_fetched,
|
|
|
|
e,
|
|
|
|
)
|
2019-08-02 19:57:57 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
mp = self.manifest.manifestProject
|
|
|
|
dissociate = mp.dissociate
|
|
|
|
if dissociate:
|
|
|
|
alternates_file = os.path.join(
|
|
|
|
self.objdir, "objects/info/alternates"
|
|
|
|
)
|
|
|
|
if os.path.exists(alternates_file):
|
|
|
|
cmd = ["repack", "-a", "-d"]
|
|
|
|
p = GitCommand(
|
|
|
|
self,
|
|
|
|
cmd,
|
|
|
|
bare=True,
|
|
|
|
capture_stdout=bool(output_redir),
|
|
|
|
merge_output=bool(output_redir),
|
|
|
|
)
|
|
|
|
if p.stdout and output_redir:
|
|
|
|
output_redir.write(p.stdout)
|
|
|
|
if p.Wait() != 0:
|
2023-07-14 23:45:35 +00:00
|
|
|
return SyncNetworkHalfResult(
|
|
|
|
remote_fetched,
|
|
|
|
GitError(
|
|
|
|
"Unable to repack alternates", project=self.name
|
|
|
|
),
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
platform_utils.remove(alternates_file)
|
|
|
|
|
|
|
|
if self.worktree:
|
|
|
|
self._InitMRef()
|
|
|
|
else:
|
|
|
|
self._InitMirrorHead()
|
|
|
|
platform_utils.remove(
|
|
|
|
os.path.join(self.gitdir, "FETCH_HEAD"), missing_ok=True
|
|
|
|
)
|
2023-07-14 23:45:35 +00:00
|
|
|
return SyncNetworkHalfResult(remote_fetched)
|
2019-08-02 19:57:57 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def PostRepoUpgrade(self):
|
|
|
|
self._InitHooks()
|
2019-08-02 19:57:57 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def _CopyAndLinkFiles(self):
|
|
|
|
if self.client.isGitcClient:
|
|
|
|
return
|
|
|
|
for copyfile in self.copyfiles:
|
|
|
|
copyfile._Copy()
|
|
|
|
for linkfile in self.linkfiles:
|
|
|
|
linkfile._Link()
|
2014-04-21 22:10:59 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def GetCommitRevisionId(self):
|
|
|
|
"""Get revisionId of a commit.
|
2012-04-12 20:04:13 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
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)
|
2020-02-20 00:19:18 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
"""
|
2023-09-10 21:35:01 +00:00
|
|
|
if self.revisionId:
|
|
|
|
return self.revisionId
|
2023-03-11 06:46:20 +00:00
|
|
|
if not self.revisionExpr.startswith(R_TAGS):
|
|
|
|
return self.GetRevisionId(self._allrefs)
|
2020-02-20 00:19:18 +00:00
|
|
|
|
|
|
|
try:
|
2023-03-11 06:46:20 +00:00
|
|
|
return self.bare_git.rev_list(self.revisionExpr, "-1")[0]
|
|
|
|
except GitError:
|
|
|
|
raise ManifestInvalidRevisionError(
|
2023-09-29 15:04:49 +00:00
|
|
|
"revision {} in {} not found".format(
|
|
|
|
self.revisionExpr, self.name
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
2011-04-07 19:51:04 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def GetRevisionId(self, all_refs=None):
|
|
|
|
if self.revisionId:
|
|
|
|
return self.revisionId
|
2011-04-07 19:51:04 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
rem = self.GetRemote()
|
|
|
|
rev = rem.ToLocal(self.revisionExpr)
|
2011-04-07 18:46:59 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if all_refs is not None and rev in all_refs:
|
|
|
|
return all_refs[rev]
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
try:
|
|
|
|
return self.bare_git.rev_parse("--verify", "%s^0" % rev)
|
|
|
|
except GitError:
|
|
|
|
raise ManifestInvalidRevisionError(
|
2023-09-29 15:04:49 +00:00
|
|
|
"revision {} in {} not found".format(
|
|
|
|
self.revisionExpr, self.name
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
def SetRevisionId(self, revisionId):
|
|
|
|
if self.revisionExpr:
|
|
|
|
self.upstream = self.revisionExpr
|
|
|
|
|
|
|
|
self.revisionId = revisionId
|
|
|
|
|
2023-07-14 23:45:35 +00:00
|
|
|
def Sync_LocalHalf(
|
|
|
|
self, syncbuf, force_sync=False, submodules=False, errors=None
|
|
|
|
):
|
2023-03-11 06:46:20 +00:00
|
|
|
"""Perform only the local IO portion of the sync process.
|
|
|
|
|
|
|
|
Network access is not required.
|
|
|
|
"""
|
2023-07-14 23:45:35 +00:00
|
|
|
if errors is None:
|
|
|
|
errors = []
|
|
|
|
|
|
|
|
def fail(error: Exception):
|
|
|
|
errors.append(error)
|
|
|
|
syncbuf.fail(self, error)
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if not os.path.exists(self.gitdir):
|
2023-07-14 23:45:35 +00:00
|
|
|
fail(
|
|
|
|
LocalSyncFail(
|
|
|
|
"Cannot checkout %s due to missing network sync; Run "
|
|
|
|
"`repo sync -n %s` first." % (self.name, self.name),
|
|
|
|
project=self.name,
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
return
|
|
|
|
|
|
|
|
self._InitWorkTree(force_sync=force_sync, submodules=submodules)
|
|
|
|
all_refs = self.bare_ref.all
|
|
|
|
self.CleanPublishedCache(all_refs)
|
|
|
|
revid = self.GetRevisionId(all_refs)
|
|
|
|
|
|
|
|
# Special case the root of the repo client checkout. Make sure it
|
|
|
|
# doesn't contain files being checked out to dirs we don't allow.
|
|
|
|
if self.relpath == ".":
|
|
|
|
PROTECTED_PATHS = {".repo"}
|
|
|
|
paths = set(
|
|
|
|
self.work_git.ls_tree("-z", "--name-only", "--", revid).split(
|
|
|
|
"\0"
|
|
|
|
)
|
|
|
|
)
|
|
|
|
bad_paths = paths & PROTECTED_PATHS
|
|
|
|
if bad_paths:
|
2023-07-14 23:45:35 +00:00
|
|
|
fail(
|
|
|
|
LocalSyncFail(
|
|
|
|
"Refusing to checkout project that writes to protected "
|
|
|
|
"paths: %s" % (", ".join(bad_paths),),
|
|
|
|
project=self.name,
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
return
|
|
|
|
|
|
|
|
def _doff():
|
|
|
|
self._FastForward(revid)
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
|
|
|
|
def _dosubmodules():
|
|
|
|
self._SyncSubmodules(quiet=True)
|
|
|
|
|
|
|
|
head = self.work_git.GetHead()
|
|
|
|
if head.startswith(R_HEADS):
|
|
|
|
branch = head[len(R_HEADS) :]
|
|
|
|
try:
|
|
|
|
head = all_refs[head]
|
|
|
|
except KeyError:
|
|
|
|
head = None
|
|
|
|
else:
|
|
|
|
branch = None
|
|
|
|
|
|
|
|
if branch is None or syncbuf.detach_head:
|
|
|
|
# Currently on a detached HEAD. The user is assumed to
|
|
|
|
# not have any local modifications worth worrying about.
|
|
|
|
if self.IsRebaseInProgress():
|
2023-07-14 23:45:35 +00:00
|
|
|
fail(_PriorSyncFailedError(project=self.name))
|
2023-03-11 06:46:20 +00:00
|
|
|
return
|
|
|
|
|
|
|
|
if head == revid:
|
|
|
|
# No changes; don't do anything further.
|
|
|
|
# Except if the head needs to be detached.
|
|
|
|
if not syncbuf.detach_head:
|
|
|
|
# The copy/linkfile config may have changed.
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
return
|
|
|
|
else:
|
|
|
|
lost = self._revlist(not_rev(revid), HEAD)
|
|
|
|
if lost:
|
|
|
|
syncbuf.info(self, "discarding %d commits", len(lost))
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
try:
|
|
|
|
self._Checkout(revid, quiet=True)
|
|
|
|
if submodules:
|
|
|
|
self._SyncSubmodules(quiet=True)
|
|
|
|
except GitError as e:
|
2023-07-14 23:45:35 +00:00
|
|
|
fail(e)
|
2023-03-11 06:46:20 +00:00
|
|
|
return
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
return
|
|
|
|
|
|
|
|
if head == revid:
|
|
|
|
# No changes; don't do anything further.
|
|
|
|
#
|
|
|
|
# The copy/linkfile config may have changed.
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
return
|
2008-10-21 14:00:00 +00:00
|
|
|
|
|
|
|
branch = self.GetBranch(branch)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
if not branch.LocalMerge:
|
|
|
|
# The current branch has no tracking configuration.
|
|
|
|
# Jump off it to a detached HEAD.
|
|
|
|
syncbuf.info(
|
|
|
|
self, "leaving %s; does not track upstream", branch.name
|
|
|
|
)
|
|
|
|
try:
|
|
|
|
self._Checkout(revid, quiet=True)
|
|
|
|
if submodules:
|
|
|
|
self._SyncSubmodules(quiet=True)
|
|
|
|
except GitError as e:
|
2023-07-14 23:45:35 +00:00
|
|
|
fail(e)
|
2023-03-11 06:46:20 +00:00
|
|
|
return
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
return
|
|
|
|
|
|
|
|
upstream_gain = self._revlist(not_rev(HEAD), revid)
|
|
|
|
|
|
|
|
# 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.
|
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
|
|
|
try:
|
2023-09-27 18:34:43 +00:00
|
|
|
self.work_git.merge_base(
|
|
|
|
"--is-ancestor", HEAD, revid, log_as_error=False
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
# Skip the published logic.
|
|
|
|
pub = False
|
|
|
|
except GitError:
|
|
|
|
pub = self.WasPublished(branch.name, all_refs)
|
|
|
|
|
|
|
|
if pub:
|
|
|
|
not_merged = self._revlist(not_rev(revid), pub)
|
|
|
|
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.
|
2023-07-14 23:45:35 +00:00
|
|
|
fail(
|
|
|
|
LocalSyncFail(
|
|
|
|
"branch %s is published (but not merged) and is "
|
|
|
|
"now %d commits behind"
|
|
|
|
% (branch.name, len(upstream_gain)),
|
|
|
|
project=self.name,
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
return
|
|
|
|
elif pub == head:
|
|
|
|
# All published commits are merged, and thus we are a
|
|
|
|
# strict subset. We can fast-forward safely.
|
|
|
|
syncbuf.later1(self, _doff)
|
|
|
|
if submodules:
|
|
|
|
syncbuf.later1(self, _dosubmodules)
|
|
|
|
return
|
|
|
|
|
|
|
|
# Examine the local commits not in the remote. Find the
|
|
|
|
# last one attributed to this user, if any.
|
|
|
|
local_changes = self._revlist(not_rev(revid), HEAD, format="%H %ce")
|
|
|
|
last_mine = None
|
|
|
|
cnt_mine = 0
|
|
|
|
for commit in local_changes:
|
|
|
|
commit_id, committer_email = commit.split(" ", 1)
|
|
|
|
if committer_email == self.UserEmail:
|
|
|
|
last_mine = commit_id
|
|
|
|
cnt_mine += 1
|
|
|
|
|
|
|
|
if not upstream_gain and cnt_mine == len(local_changes):
|
|
|
|
# The copy/linkfile config may have changed.
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
return
|
|
|
|
|
|
|
|
if self.IsDirty(consider_untracked=False):
|
2023-07-14 23:45:35 +00:00
|
|
|
fail(_DirtyError(project=self.name))
|
2023-03-11 06:46:20 +00:00
|
|
|
return
|
|
|
|
|
|
|
|
# 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)
|
|
|
|
|
|
|
|
if cnt_mine < len(local_changes):
|
|
|
|
# Upstream rebased. Not everything in HEAD was created by this user.
|
|
|
|
syncbuf.info(
|
|
|
|
self,
|
|
|
|
"discarding %d commits removed from upstream",
|
|
|
|
len(local_changes) - cnt_mine,
|
|
|
|
)
|
|
|
|
|
|
|
|
branch.remote = self.GetRemote()
|
2023-09-11 11:38:00 +00:00
|
|
|
if not IsId(self.revisionExpr):
|
2023-03-11 06:46:20 +00:00
|
|
|
# In case of manifest sync the revisionExpr might be a SHA1.
|
|
|
|
branch.merge = self.revisionExpr
|
|
|
|
if not branch.merge.startswith("refs/"):
|
|
|
|
branch.merge = R_HEADS + branch.merge
|
|
|
|
branch.Save()
|
|
|
|
|
|
|
|
if cnt_mine > 0 and self.rebase:
|
|
|
|
|
|
|
|
def _docopyandlink():
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
|
|
|
|
def _dorebase():
|
|
|
|
self._Rebase(upstream="%s^1" % last_mine, onto=revid)
|
|
|
|
|
|
|
|
syncbuf.later2(self, _dorebase)
|
|
|
|
if submodules:
|
|
|
|
syncbuf.later2(self, _dosubmodules)
|
|
|
|
syncbuf.later2(self, _docopyandlink)
|
|
|
|
elif local_changes:
|
|
|
|
try:
|
|
|
|
self._ResetHard(revid)
|
|
|
|
if submodules:
|
|
|
|
self._SyncSubmodules(quiet=True)
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
except GitError as e:
|
2023-07-14 23:45:35 +00:00
|
|
|
fail(e)
|
2023-03-11 06:46:20 +00:00
|
|
|
return
|
|
|
|
else:
|
|
|
|
syncbuf.later1(self, _doff)
|
|
|
|
if submodules:
|
|
|
|
syncbuf.later1(self, _dosubmodules)
|
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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def AddCopyFile(self, src, dest, topdir):
|
|
|
|
"""Mark |src| for copying to |dest| (relative to |topdir|).
|
2020-02-19 20:50:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
No filesystem changes occur here. Actual copying happens later on.
|
2020-02-19 20:50:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Paths should have basic validation run on them before being queued.
|
|
|
|
Further checking will be handled when the actual copy happens.
|
|
|
|
"""
|
|
|
|
self.copyfiles.append(_CopyFile(self.worktree, src, topdir, dest))
|
2020-09-06 19:51:21 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def AddLinkFile(self, src, dest, topdir):
|
|
|
|
"""Mark |dest| to create a symlink (relative to |topdir|) pointing to
|
|
|
|
|src|.
|
2020-09-06 19:51:21 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
No filesystem changes occur here. Actual linking happens later on.
|
2020-09-06 19:51:21 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Paths should have basic validation run on them before being queued.
|
|
|
|
Further checking will be handled when the actual link happens.
|
|
|
|
"""
|
|
|
|
self.linkfiles.append(_LinkFile(self.worktree, src, topdir, dest))
|
2020-09-06 19:51:21 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def AddAnnotation(self, name, value, keep):
|
|
|
|
self.annotations.append(Annotation(name, value, keep))
|
2020-09-06 19:51:21 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def DownloadPatchSet(self, change_id, patch_id):
|
|
|
|
"""Download a single patch set of a single change to FETCH_HEAD."""
|
|
|
|
remote = self.GetRemote()
|
2011-08-26 00:21:47 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
cmd = ["fetch", remote.name]
|
|
|
|
cmd.append(
|
|
|
|
"refs/changes/%2.2d/%d/%d" % (change_id % 100, change_id, patch_id)
|
|
|
|
)
|
2023-08-08 21:12:53 +00:00
|
|
|
GitCommand(self, cmd, bare=True, verify_command=True).Wait()
|
2023-03-11 06:46:20 +00:00
|
|
|
return DownloadedChange(
|
|
|
|
self,
|
|
|
|
self.GetRevisionId(),
|
|
|
|
change_id,
|
|
|
|
patch_id,
|
|
|
|
self.bare_git.rev_parse("FETCH_HEAD"),
|
|
|
|
)
|
2009-04-11 01:53:46 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def DeleteWorktree(self, quiet=False, force=False):
|
|
|
|
"""Delete the source checkout and any other housekeeping tasks.
|
2009-04-11 01:53:46 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
This currently leaves behind the internal .repo/ cache state. This
|
|
|
|
helps when switching branches or manifest changes get reverted as we
|
|
|
|
don't have to redownload all the git objects. But we should do some GC
|
|
|
|
at some point.
|
2010-10-08 08:02:09 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Args:
|
|
|
|
quiet: Whether to hide normal messages.
|
|
|
|
force: Always delete tree even if dirty.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
True if the worktree was completely cleaned out.
|
|
|
|
"""
|
|
|
|
if self.IsDirty():
|
|
|
|
if force:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.warn(
|
2023-03-11 06:46:20 +00:00
|
|
|
"warning: %s: Removing dirty project: uncommitted changes "
|
2023-09-14 08:17:20 +00:00
|
|
|
"lost.",
|
|
|
|
self.RelPath(local=False),
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
else:
|
2023-07-14 23:45:35 +00:00
|
|
|
msg = (
|
|
|
|
"error: %s: Cannot remove project: uncommitted"
|
|
|
|
"changes are present.\n" % self.RelPath(local=False)
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(msg)
|
2023-07-14 23:45:35 +00:00
|
|
|
raise DeleteDirtyWorktreeError(msg, project=self)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
if not quiet:
|
|
|
|
print(
|
2023-09-29 15:04:49 +00:00
|
|
|
"{}: Deleting obsolete checkout.".format(
|
|
|
|
self.RelPath(local=False)
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
# Unlock and delink from the main worktree. We don't use git's worktree
|
|
|
|
# remove because it will recursively delete projects -- we handle that
|
|
|
|
# ourselves below. https://crbug.com/git/48
|
|
|
|
if self.use_git_worktrees:
|
|
|
|
needle = platform_utils.realpath(self.gitdir)
|
|
|
|
# Find the git worktree commondir under .repo/worktrees/.
|
|
|
|
output = self.bare_git.worktree("list", "--porcelain").splitlines()[
|
|
|
|
0
|
|
|
|
]
|
|
|
|
assert output.startswith("worktree "), output
|
|
|
|
commondir = output[9:]
|
|
|
|
# Walk each of the git worktrees to see where they point.
|
|
|
|
configs = os.path.join(commondir, "worktrees")
|
|
|
|
for name in os.listdir(configs):
|
|
|
|
gitdir = os.path.join(configs, name, "gitdir")
|
|
|
|
with open(gitdir) as fp:
|
|
|
|
relpath = fp.read().strip()
|
|
|
|
# Resolve the checkout path and see if it matches this project.
|
|
|
|
fullpath = platform_utils.realpath(
|
|
|
|
os.path.join(configs, name, relpath)
|
|
|
|
)
|
|
|
|
if fullpath == needle:
|
|
|
|
platform_utils.rmtree(os.path.join(configs, name))
|
|
|
|
|
|
|
|
# Delete the .git directory first, so we're less likely to have a
|
|
|
|
# partially working git repository around. There shouldn't be any git
|
|
|
|
# projects here, so rmtree works.
|
|
|
|
|
|
|
|
# Try to remove plain files first in case of git worktrees. If this
|
|
|
|
# fails for any reason, we'll fall back to rmtree, and that'll display
|
|
|
|
# errors if it can't remove things either.
|
2022-11-03 20:51:19 +00:00
|
|
|
try:
|
2023-03-11 06:46:20 +00:00
|
|
|
platform_utils.remove(self.gitdir)
|
2022-11-03 20:51:19 +00:00
|
|
|
except OSError:
|
2023-03-11 06:46:20 +00:00
|
|
|
pass
|
|
|
|
try:
|
|
|
|
platform_utils.rmtree(self.gitdir)
|
|
|
|
except OSError as e:
|
|
|
|
if e.errno != errno.ENOENT:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("error: %s: %s", self.gitdir, e)
|
|
|
|
logger.error(
|
2023-03-11 06:46:20 +00:00
|
|
|
"error: %s: Failed to delete obsolete checkout; remove "
|
2023-09-14 08:17:20 +00:00
|
|
|
"manually, then run `repo sync -l`.",
|
|
|
|
self.RelPath(local=False),
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
2023-07-14 23:45:35 +00:00
|
|
|
raise DeleteWorktreeError(aggregate_errors=[e])
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
# Delete everything under the worktree, except for directories that
|
|
|
|
# contain another git project.
|
|
|
|
dirs_to_remove = []
|
|
|
|
failed = False
|
2023-07-14 23:45:35 +00:00
|
|
|
errors = []
|
2023-03-11 06:46:20 +00:00
|
|
|
for root, dirs, files in platform_utils.walk(self.worktree):
|
|
|
|
for f in files:
|
|
|
|
path = os.path.join(root, f)
|
|
|
|
try:
|
|
|
|
platform_utils.remove(path)
|
|
|
|
except OSError as e:
|
|
|
|
if e.errno != errno.ENOENT:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("error: %s: Failed to remove: %s", path, e)
|
2023-03-11 06:46:20 +00:00
|
|
|
failed = True
|
2023-07-14 23:45:35 +00:00
|
|
|
errors.append(e)
|
2023-03-11 06:46:20 +00:00
|
|
|
dirs[:] = [
|
|
|
|
d
|
|
|
|
for d in dirs
|
|
|
|
if not os.path.lexists(os.path.join(root, d, ".git"))
|
|
|
|
]
|
|
|
|
dirs_to_remove += [
|
|
|
|
os.path.join(root, d)
|
|
|
|
for d in dirs
|
|
|
|
if os.path.join(root, d) not in dirs_to_remove
|
|
|
|
]
|
|
|
|
for d in reversed(dirs_to_remove):
|
|
|
|
if platform_utils.islink(d):
|
|
|
|
try:
|
|
|
|
platform_utils.remove(d)
|
|
|
|
except OSError as e:
|
|
|
|
if e.errno != errno.ENOENT:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("error: %s: Failed to remove: %s", d, e)
|
2023-03-11 06:46:20 +00:00
|
|
|
failed = True
|
2023-07-14 23:45:35 +00:00
|
|
|
errors.append(e)
|
2023-03-11 06:46:20 +00:00
|
|
|
elif not platform_utils.listdir(d):
|
|
|
|
try:
|
|
|
|
platform_utils.rmdir(d)
|
|
|
|
except OSError as e:
|
|
|
|
if e.errno != errno.ENOENT:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("error: %s: Failed to remove: %s", d, e)
|
2023-03-11 06:46:20 +00:00
|
|
|
failed = True
|
2023-07-14 23:45:35 +00:00
|
|
|
errors.append(e)
|
2023-03-11 06:46:20 +00:00
|
|
|
if failed:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
|
|
|
"error: %s: Failed to delete obsolete checkout.",
|
|
|
|
self.RelPath(local=False),
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
2023-03-11 06:46:20 +00:00
|
|
|
" Remove manually, then run `repo sync -l`.",
|
|
|
|
)
|
2023-07-14 23:45:35 +00:00
|
|
|
raise DeleteWorktreeError(aggregate_errors=errors)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
# Try deleting parent dirs if they are empty.
|
|
|
|
path = self.worktree
|
|
|
|
while path != self.manifest.topdir:
|
|
|
|
try:
|
|
|
|
platform_utils.rmdir(path)
|
|
|
|
except OSError as e:
|
|
|
|
if e.errno != errno.ENOENT:
|
|
|
|
break
|
|
|
|
path = os.path.dirname(path)
|
2012-08-30 16:39:36 +00:00
|
|
|
|
2012-08-02 21:57:37 +00:00
|
|
|
return True
|
2011-09-19 21:50:58 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def StartBranch(self, name, branch_merge="", revision=None):
|
|
|
|
"""Create a new branch off the manifest's revision."""
|
|
|
|
if not branch_merge:
|
|
|
|
branch_merge = self.revisionExpr
|
|
|
|
head = self.work_git.GetHead()
|
|
|
|
if head == (R_HEADS + name):
|
|
|
|
return True
|
|
|
|
|
|
|
|
all_refs = self.bare_ref.all
|
|
|
|
if R_HEADS + name in all_refs:
|
2023-08-08 21:12:53 +00:00
|
|
|
GitCommand(
|
|
|
|
self, ["checkout", "-q", name, "--"], verify_command=True
|
|
|
|
).Wait()
|
|
|
|
return True
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
branch = self.GetBranch(name)
|
|
|
|
branch.remote = self.GetRemote()
|
|
|
|
branch.merge = branch_merge
|
2023-09-11 11:38:00 +00:00
|
|
|
if not branch.merge.startswith("refs/") and not IsId(branch_merge):
|
2023-03-11 06:46:20 +00:00
|
|
|
branch.merge = R_HEADS + branch_merge
|
|
|
|
|
|
|
|
if revision is None:
|
|
|
|
revid = self.GetRevisionId(all_refs)
|
2013-06-03 19:15:23 +00:00
|
|
|
else:
|
2023-03-11 06:46:20 +00:00
|
|
|
revid = self.work_git.rev_parse(revision)
|
|
|
|
|
|
|
|
if head.startswith(R_HEADS):
|
|
|
|
try:
|
|
|
|
head = all_refs[head]
|
|
|
|
except KeyError:
|
|
|
|
head = None
|
|
|
|
if revid and head and revid == head:
|
|
|
|
ref = R_HEADS + name
|
|
|
|
self.work_git.update_ref(ref, revid)
|
|
|
|
self.work_git.symbolic_ref(HEAD, ref)
|
|
|
|
branch.Save()
|
|
|
|
return True
|
|
|
|
|
2023-08-08 21:12:53 +00:00
|
|
|
GitCommand(
|
|
|
|
self,
|
|
|
|
["checkout", "-q", "-b", branch.name, revid],
|
|
|
|
verify_command=True,
|
|
|
|
).Wait()
|
|
|
|
branch.Save()
|
|
|
|
return True
|
2014-10-16 22:02:58 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def CheckoutBranch(self, name):
|
|
|
|
"""Checkout a local topic branch.
|
2021-11-15 17:39:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Args:
|
|
|
|
name: The name of the branch to checkout.
|
|
|
|
|
|
|
|
Returns:
|
2023-08-08 21:12:53 +00:00
|
|
|
True if the checkout succeeded; False if the
|
|
|
|
branch doesn't exist.
|
2023-03-11 06:46:20 +00:00
|
|
|
"""
|
|
|
|
rev = R_HEADS + name
|
|
|
|
head = self.work_git.GetHead()
|
|
|
|
if head == rev:
|
|
|
|
# Already on the branch.
|
|
|
|
return True
|
|
|
|
|
|
|
|
all_refs = self.bare_ref.all
|
2014-11-12 18:27:45 +00:00
|
|
|
try:
|
2023-03-11 06:46:20 +00:00
|
|
|
revid = all_refs[rev]
|
|
|
|
except KeyError:
|
|
|
|
# Branch does not exist in this project.
|
2023-08-08 21:12:53 +00:00
|
|
|
return False
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
if head.startswith(R_HEADS):
|
2014-11-12 18:27:45 +00:00
|
|
|
try:
|
2023-03-11 06:46:20 +00:00
|
|
|
head = all_refs[head]
|
|
|
|
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(
|
|
|
|
self.work_git.GetDotgitPath(subpath=HEAD),
|
2023-09-29 15:04:49 +00:00
|
|
|
f"ref: {R_HEADS}{name}\n",
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
return True
|
|
|
|
|
2023-08-08 21:12:53 +00:00
|
|
|
GitCommand(
|
|
|
|
self,
|
|
|
|
["checkout", name, "--"],
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
|
|
|
verify_command=True,
|
|
|
|
).Wait()
|
|
|
|
return True
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def AbandonBranch(self, name):
|
|
|
|
"""Destroy a local topic branch.
|
2010-11-26 12:42:13 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Args:
|
|
|
|
name: The name of the branch to abandon.
|
2021-11-14 04:29:42 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Returns:
|
2023-08-03 21:38:00 +00:00
|
|
|
True if the abandon succeeded; Raises GitCommandError if it didn't;
|
|
|
|
None if the branch didn't exist.
|
2023-03-11 06:46:20 +00:00
|
|
|
"""
|
|
|
|
rev = R_HEADS + name
|
|
|
|
all_refs = self.bare_ref.all
|
|
|
|
if rev not in all_refs:
|
|
|
|
# Doesn't exist
|
|
|
|
return None
|
|
|
|
|
|
|
|
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.
|
|
|
|
head = all_refs[head]
|
|
|
|
|
|
|
|
revid = self.GetRevisionId(all_refs)
|
|
|
|
if head == revid:
|
|
|
|
_lwrite(
|
|
|
|
self.work_git.GetDotgitPath(subpath=HEAD), "%s\n" % revid
|
|
|
|
)
|
|
|
|
else:
|
|
|
|
self._Checkout(revid, quiet=True)
|
2023-08-03 21:38:00 +00:00
|
|
|
GitCommand(
|
|
|
|
self,
|
|
|
|
["branch", "-D", name],
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
|
|
|
verify_command=True,
|
|
|
|
).Wait()
|
|
|
|
return True
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def PruneHeads(self):
|
|
|
|
"""Prune any topic branches already merged into upstream."""
|
|
|
|
cb = self.CurrentBranch
|
|
|
|
kill = []
|
|
|
|
left = self._allrefs
|
|
|
|
for name in left.keys():
|
|
|
|
if name.startswith(R_HEADS):
|
|
|
|
name = name[len(R_HEADS) :]
|
|
|
|
if cb is None or name != cb:
|
|
|
|
kill.append(name)
|
|
|
|
|
|
|
|
# Minor optimization: If there's nothing to prune, then don't try to
|
|
|
|
# read any project state.
|
|
|
|
if not kill and not cb:
|
|
|
|
return []
|
|
|
|
|
|
|
|
rev = self.GetRevisionId(left)
|
|
|
|
if (
|
|
|
|
cb is not None
|
|
|
|
and not self._revlist(HEAD + "..." + rev)
|
|
|
|
and not self.IsDirty(consider_untracked=False)
|
|
|
|
):
|
|
|
|
self.work_git.DetachHead(HEAD)
|
|
|
|
kill.append(cb)
|
|
|
|
|
|
|
|
if kill:
|
|
|
|
old = self.bare_git.GetHead()
|
2008-10-21 14:00:00 +00:00
|
|
|
|
2023-03-11 06:46:20 +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:
|
2023-09-11 11:38:00 +00:00
|
|
|
if IsId(old):
|
2023-03-11 06:46:20 +00:00
|
|
|
self.bare_git.DetachHead(old)
|
|
|
|
else:
|
|
|
|
self.bare_git.SetHead(old)
|
|
|
|
left = self._allrefs
|
|
|
|
|
|
|
|
for branch in kill:
|
|
|
|
if (R_HEADS + branch) not in left:
|
|
|
|
self.CleanPublishedCache()
|
|
|
|
break
|
|
|
|
|
|
|
|
if cb and cb not in kill:
|
|
|
|
kill.append(cb)
|
|
|
|
kill.sort()
|
|
|
|
|
|
|
|
kept = []
|
|
|
|
for branch in kill:
|
|
|
|
if R_HEADS + branch in left:
|
|
|
|
branch = self.GetBranch(branch)
|
|
|
|
base = branch.LocalMerge
|
|
|
|
if not base:
|
|
|
|
base = rev
|
|
|
|
kept.append(ReviewableBranch(self, branch, base))
|
|
|
|
return kept
|
|
|
|
|
|
|
|
def GetRegisteredSubprojects(self):
|
|
|
|
result = []
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
re_path = re.compile(r"^submodule\.(.+)\.path=(.*)$")
|
|
|
|
re_url = re.compile(r"^submodule\.(.+)\.url=(.*)$")
|
|
|
|
|
|
|
|
def parse_gitmodules(gitdir, rev):
|
|
|
|
cmd = ["cat-file", "blob", "%s:.gitmodules" % rev]
|
|
|
|
try:
|
|
|
|
p = GitCommand(
|
|
|
|
None,
|
|
|
|
cmd,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
|
|
|
bare=True,
|
|
|
|
gitdir=gitdir,
|
|
|
|
)
|
|
|
|
except GitError:
|
|
|
|
return [], []
|
|
|
|
if p.Wait() != 0:
|
|
|
|
return [], []
|
|
|
|
|
|
|
|
gitmodules_lines = []
|
|
|
|
fd, temp_gitmodules_path = tempfile.mkstemp()
|
|
|
|
try:
|
|
|
|
os.write(fd, p.stdout.encode("utf-8"))
|
|
|
|
os.close(fd)
|
|
|
|
cmd = ["config", "--file", temp_gitmodules_path, "--list"]
|
|
|
|
p = GitCommand(
|
|
|
|
None,
|
|
|
|
cmd,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
|
|
|
bare=True,
|
|
|
|
gitdir=gitdir,
|
|
|
|
)
|
|
|
|
if p.Wait() != 0:
|
|
|
|
return [], []
|
|
|
|
gitmodules_lines = p.stdout.split("\n")
|
|
|
|
except GitError:
|
|
|
|
return [], []
|
|
|
|
finally:
|
|
|
|
platform_utils.remove(temp_gitmodules_path)
|
|
|
|
|
|
|
|
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:
|
|
|
|
p = GitCommand(
|
|
|
|
None,
|
|
|
|
cmd,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
|
|
|
bare=True,
|
|
|
|
gitdir=gitdir,
|
|
|
|
)
|
|
|
|
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
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
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)
|
|
|
|
(
|
|
|
|
relpath,
|
|
|
|
worktree,
|
|
|
|
gitdir,
|
|
|
|
objdir,
|
|
|
|
) = self.manifest.GetSubprojectPaths(self, name, path)
|
|
|
|
project = self.manifest.paths.get(relpath)
|
|
|
|
if project:
|
|
|
|
result.extend(project.GetDerivedSubprojects())
|
|
|
|
continue
|
|
|
|
|
|
|
|
if url.startswith(".."):
|
|
|
|
url = urllib.parse.urljoin("%s/" % self.remote.url, url)
|
|
|
|
remote = RemoteSpec(
|
|
|
|
self.remote.name,
|
|
|
|
url=url,
|
|
|
|
pushUrl=self.remote.pushUrl,
|
|
|
|
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,
|
|
|
|
revisionExpr=rev,
|
|
|
|
revisionId=rev,
|
|
|
|
rebase=self.rebase,
|
|
|
|
groups=self.groups,
|
|
|
|
sync_c=self.sync_c,
|
|
|
|
sync_s=self.sync_s,
|
|
|
|
sync_tags=self.sync_tags,
|
|
|
|
parent=self,
|
|
|
|
is_derived=True,
|
|
|
|
)
|
|
|
|
result.append(subproject)
|
|
|
|
result.extend(subproject.GetDerivedSubprojects())
|
|
|
|
return result
|
|
|
|
|
|
|
|
def EnableRepositoryExtension(self, key, value="true", version=1):
|
|
|
|
"""Enable git repository extension |key| with |value|.
|
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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Args:
|
|
|
|
key: The extension to enabled. Omit the "extensions." prefix.
|
|
|
|
value: The value to use for the extension.
|
|
|
|
version: The minimum git repository version needed.
|
|
|
|
"""
|
|
|
|
# Make sure the git repo version is new enough already.
|
|
|
|
found_version = self.config.GetInt("core.repositoryFormatVersion")
|
|
|
|
if found_version is None:
|
|
|
|
found_version = 0
|
|
|
|
if found_version < version:
|
|
|
|
self.config.SetString("core.repositoryFormatVersion", str(version))
|
|
|
|
|
|
|
|
# Enable the extension!
|
2023-09-29 15:04:49 +00:00
|
|
|
self.config.SetString(f"extensions.{key}", value)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
def ResolveRemoteHead(self, name=None):
|
|
|
|
"""Find out what the default branch (HEAD) points to.
|
|
|
|
|
|
|
|
Normally this points to refs/heads/master, but projects are moving to
|
|
|
|
main. Support whatever the server uses rather than hardcoding "master"
|
|
|
|
ourselves.
|
|
|
|
"""
|
|
|
|
if name is None:
|
|
|
|
name = self.remote.name
|
|
|
|
|
|
|
|
# The output will look like (NB: tabs are separators):
|
|
|
|
# ref: refs/heads/master HEAD
|
|
|
|
# 5f6803b100bb3cd0f534e96e88c91373e8ed1c44 HEAD
|
|
|
|
output = self.bare_git.ls_remote(
|
|
|
|
"-q", "--symref", "--exit-code", name, "HEAD"
|
|
|
|
)
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
for line in output.splitlines():
|
|
|
|
lhs, rhs = line.split("\t", 1)
|
|
|
|
if rhs == "HEAD" and lhs.startswith("ref:"):
|
|
|
|
return lhs[4:].strip()
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
return None
|
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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def _CheckForImmutableRevision(self):
|
|
|
|
try:
|
|
|
|
# if revision (sha or tag) is not present then following function
|
|
|
|
# throws an error.
|
|
|
|
self.bare_git.rev_list(
|
2023-09-27 18:34:43 +00:00
|
|
|
"-1",
|
|
|
|
"--missing=allow-any",
|
|
|
|
"%s^0" % self.revisionExpr,
|
|
|
|
"--",
|
|
|
|
log_as_error=False,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
if self.upstream:
|
|
|
|
rev = self.GetRemote().ToLocal(self.upstream)
|
|
|
|
self.bare_git.rev_list(
|
2023-09-27 18:34:43 +00:00
|
|
|
"-1",
|
|
|
|
"--missing=allow-any",
|
|
|
|
"%s^0" % rev,
|
|
|
|
"--",
|
|
|
|
log_as_error=False,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
self.bare_git.merge_base(
|
2023-09-27 18:34:43 +00:00
|
|
|
"--is-ancestor",
|
|
|
|
self.revisionExpr,
|
|
|
|
rev,
|
|
|
|
log_as_error=False,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
return True
|
|
|
|
except GitError:
|
|
|
|
# There is no such persistent revision. We have to fetch it.
|
|
|
|
return False
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +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(local=False))
|
|
|
|
cmd.append(self.revisionExpr)
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
command = GitCommand(
|
2023-07-14 23:45:35 +00:00
|
|
|
self,
|
|
|
|
cmd,
|
|
|
|
cwd=cwd,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
|
|
|
verify_command=True,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
2023-07-14 23:45:35 +00:00
|
|
|
command.Wait()
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
def _RemoteFetch(
|
|
|
|
self,
|
|
|
|
name=None,
|
|
|
|
current_branch_only=False,
|
|
|
|
initial=False,
|
|
|
|
quiet=False,
|
|
|
|
verbose=False,
|
|
|
|
output_redir=None,
|
|
|
|
alt_dir=None,
|
|
|
|
tags=True,
|
|
|
|
prune=False,
|
|
|
|
depth=None,
|
|
|
|
submodules=False,
|
|
|
|
ssh_proxy=None,
|
|
|
|
force_sync=False,
|
|
|
|
clone_filter=None,
|
|
|
|
retry_fetches=2,
|
|
|
|
retry_sleep_initial_sec=4.0,
|
|
|
|
retry_exp_factor=2.0,
|
2023-07-14 23:45:35 +00:00
|
|
|
) -> bool:
|
2023-03-11 06:46:20 +00:00
|
|
|
tag_name = None
|
|
|
|
# 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.
|
|
|
|
# The repo project should also never be synced with partial depth.
|
|
|
|
if self.manifest.IsMirror or self.relpath == ".repo/repo":
|
|
|
|
depth = None
|
|
|
|
|
|
|
|
if depth:
|
|
|
|
current_branch_only = True
|
|
|
|
|
2023-09-11 11:38:00 +00:00
|
|
|
is_sha1 = bool(IsId(self.revisionExpr))
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
if current_branch_only:
|
|
|
|
if self.revisionExpr.startswith(R_TAGS):
|
|
|
|
# This is a tag and its commit id should never change.
|
|
|
|
tag_name = self.revisionExpr[len(R_TAGS) :]
|
|
|
|
elif self.upstream and self.upstream.startswith(R_TAGS):
|
|
|
|
# This is a tag and its commit id should never change.
|
|
|
|
tag_name = self.upstream[len(R_TAGS) :]
|
|
|
|
|
|
|
|
if is_sha1 or tag_name is not None:
|
|
|
|
if self._CheckForImmutableRevision():
|
|
|
|
if verbose:
|
|
|
|
print(
|
|
|
|
"Skipped fetching project %s (already have "
|
|
|
|
"persistent ref)" % self.name
|
|
|
|
)
|
|
|
|
return True
|
|
|
|
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.
|
|
|
|
if self.upstream:
|
2023-09-11 11:38:00 +00:00
|
|
|
current_branch_only = not IsId(self.upstream)
|
2023-03-11 06:46:20 +00:00
|
|
|
else:
|
|
|
|
current_branch_only = False
|
|
|
|
|
|
|
|
if not name:
|
|
|
|
name = self.remote.name
|
|
|
|
|
|
|
|
remote = self.GetRemote(name)
|
|
|
|
if not remote.PreConnectFetch(ssh_proxy):
|
|
|
|
ssh_proxy = None
|
|
|
|
|
|
|
|
if initial:
|
|
|
|
if alt_dir and "objects" == os.path.basename(alt_dir):
|
|
|
|
ref_dir = os.path.dirname(alt_dir)
|
|
|
|
packed_refs = os.path.join(self.gitdir, "packed-refs")
|
|
|
|
|
|
|
|
all_refs = self.bare_ref.all
|
|
|
|
ids = set(all_refs.values())
|
|
|
|
tmp = set()
|
|
|
|
|
|
|
|
for r, ref_id in GitRefs(ref_dir).all.items():
|
|
|
|
if r not in all_refs:
|
|
|
|
if r.startswith(R_TAGS) or remote.WritesTo(r):
|
|
|
|
all_refs[r] = ref_id
|
|
|
|
ids.add(ref_id)
|
|
|
|
continue
|
|
|
|
|
|
|
|
if ref_id in ids:
|
|
|
|
continue
|
|
|
|
|
|
|
|
r = "refs/_alt/%s" % ref_id
|
|
|
|
all_refs[r] = ref_id
|
|
|
|
ids.add(ref_id)
|
|
|
|
tmp.add(r)
|
|
|
|
|
|
|
|
tmp_packed_lines = []
|
|
|
|
old_packed_lines = []
|
|
|
|
|
|
|
|
for r in sorted(all_refs):
|
2023-09-29 15:04:49 +00:00
|
|
|
line = f"{all_refs[r]} {r}\n"
|
2023-03-11 06:46:20 +00:00
|
|
|
tmp_packed_lines.append(line)
|
|
|
|
if r not in tmp:
|
|
|
|
old_packed_lines.append(line)
|
|
|
|
|
|
|
|
tmp_packed = "".join(tmp_packed_lines)
|
|
|
|
old_packed = "".join(old_packed_lines)
|
|
|
|
_lwrite(packed_refs, tmp_packed)
|
|
|
|
else:
|
|
|
|
alt_dir = None
|
|
|
|
|
|
|
|
cmd = ["fetch"]
|
|
|
|
|
|
|
|
if clone_filter:
|
|
|
|
git_require((2, 19, 0), fail=True, msg="partial clones")
|
|
|
|
cmd.append("--filter=%s" % clone_filter)
|
|
|
|
self.EnableRepositoryExtension("partialclone", self.remote.name)
|
|
|
|
|
|
|
|
if depth:
|
|
|
|
cmd.append("--depth=%s" % depth)
|
|
|
|
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")
|
|
|
|
|
|
|
|
if not verbose:
|
|
|
|
cmd.append("--quiet")
|
|
|
|
if not quiet and sys.stdout.isatty():
|
|
|
|
cmd.append("--progress")
|
|
|
|
if not self.worktree:
|
|
|
|
cmd.append("--update-head-ok")
|
|
|
|
cmd.append(name)
|
|
|
|
|
|
|
|
if force_sync:
|
|
|
|
cmd.append("--force")
|
|
|
|
|
|
|
|
if prune:
|
|
|
|
cmd.append("--prune")
|
|
|
|
|
|
|
|
# Always pass something for --recurse-submodules, git with GIT_DIR
|
|
|
|
# behaves incorrectly when not given `--recurse-submodules=no`.
|
|
|
|
# (b/218891912)
|
|
|
|
cmd.append(
|
|
|
|
f'--recurse-submodules={"on-demand" if submodules else "no"}'
|
|
|
|
)
|
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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
spec = []
|
|
|
|
if not current_branch_only:
|
|
|
|
# Fetch whole repo.
|
|
|
|
spec.append(
|
|
|
|
str(("+refs/heads/*:") + remote.ToLocal("refs/heads/*"))
|
|
|
|
)
|
|
|
|
elif tag_name is not None:
|
|
|
|
spec.append("tag")
|
|
|
|
spec.append(tag_name)
|
|
|
|
|
|
|
|
if self.manifest.IsMirror and not current_branch_only:
|
|
|
|
branch = None
|
|
|
|
else:
|
|
|
|
branch = self.revisionExpr
|
|
|
|
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)
|
|
|
|
if self.upstream:
|
|
|
|
spec.append(self.upstream)
|
|
|
|
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(("+%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(("+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 not tags or depth:
|
|
|
|
cmd.append("--no-tags")
|
|
|
|
else:
|
|
|
|
cmd.append("--tags")
|
|
|
|
spec.append(str(("+refs/tags/*:") + remote.ToLocal("refs/tags/*")))
|
|
|
|
|
|
|
|
cmd.extend(spec)
|
|
|
|
|
|
|
|
# At least one retry minimum due to git remote prune.
|
|
|
|
retry_fetches = max(retry_fetches, 2)
|
|
|
|
retry_cur_sleep = retry_sleep_initial_sec
|
|
|
|
ok = prune_tried = False
|
|
|
|
for try_n in range(retry_fetches):
|
2023-07-14 23:45:35 +00:00
|
|
|
verify_command = try_n == retry_fetches - 1
|
2023-03-11 06:46:20 +00:00
|
|
|
gitcmd = GitCommand(
|
|
|
|
self,
|
|
|
|
cmd,
|
|
|
|
bare=True,
|
|
|
|
objdir=os.path.join(self.objdir, "objects"),
|
|
|
|
ssh_proxy=ssh_proxy,
|
|
|
|
merge_output=True,
|
|
|
|
capture_stdout=quiet or bool(output_redir),
|
2023-07-14 23:45:35 +00:00
|
|
|
verify_command=verify_command,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
if gitcmd.stdout and not quiet and output_redir:
|
|
|
|
output_redir.write(gitcmd.stdout)
|
|
|
|
ret = gitcmd.Wait()
|
|
|
|
if ret == 0:
|
|
|
|
ok = True
|
|
|
|
break
|
|
|
|
|
|
|
|
# Retry later due to HTTP 429 Too Many Requests.
|
|
|
|
elif (
|
|
|
|
gitcmd.stdout
|
|
|
|
and "error:" in gitcmd.stdout
|
|
|
|
and "HTTP 429" in gitcmd.stdout
|
|
|
|
):
|
|
|
|
# Fallthru to sleep+retry logic at the bottom.
|
|
|
|
pass
|
|
|
|
|
|
|
|
# Try to prune remote branches once in case there are conflicts.
|
|
|
|
# For example, if the remote had refs/heads/upstream, but deleted
|
|
|
|
# that and now has refs/heads/upstream/foo.
|
|
|
|
elif (
|
|
|
|
gitcmd.stdout
|
|
|
|
and "error:" in gitcmd.stdout
|
|
|
|
and "git remote prune" in gitcmd.stdout
|
|
|
|
and not prune_tried
|
|
|
|
):
|
|
|
|
prune_tried = True
|
|
|
|
prunecmd = GitCommand(
|
|
|
|
self,
|
|
|
|
["remote", "prune", name],
|
|
|
|
bare=True,
|
|
|
|
ssh_proxy=ssh_proxy,
|
|
|
|
)
|
|
|
|
ret = prunecmd.Wait()
|
|
|
|
if ret:
|
|
|
|
break
|
|
|
|
print(
|
|
|
|
"retrying fetch after pruning remote branches",
|
|
|
|
file=output_redir,
|
|
|
|
)
|
|
|
|
# Continue right away so we don't sleep as we shouldn't need to.
|
|
|
|
continue
|
|
|
|
elif current_branch_only and is_sha1 and ret == 128:
|
|
|
|
# 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.
|
|
|
|
break
|
|
|
|
elif ret < 0:
|
|
|
|
# Git died with a signal, exit immediately.
|
|
|
|
break
|
|
|
|
|
|
|
|
# Figure out how long to sleep before the next attempt, if there is
|
|
|
|
# one.
|
|
|
|
if not verbose and gitcmd.stdout:
|
|
|
|
print(
|
2023-09-29 15:04:49 +00:00
|
|
|
f"\n{self.name}:\n{gitcmd.stdout}",
|
2023-03-11 06:46:20 +00:00
|
|
|
end="",
|
|
|
|
file=output_redir,
|
|
|
|
)
|
|
|
|
if try_n < retry_fetches - 1:
|
|
|
|
print(
|
|
|
|
"%s: sleeping %s seconds before retrying"
|
|
|
|
% (self.name, retry_cur_sleep),
|
|
|
|
file=output_redir,
|
|
|
|
)
|
|
|
|
time.sleep(retry_cur_sleep)
|
|
|
|
retry_cur_sleep = min(
|
|
|
|
retry_exp_factor * retry_cur_sleep, MAXIMUM_RETRY_SLEEP_SEC
|
|
|
|
)
|
|
|
|
retry_cur_sleep *= 1 - random.uniform(
|
|
|
|
-RETRY_JITTER_PERCENT, RETRY_JITTER_PERCENT
|
|
|
|
)
|
|
|
|
|
|
|
|
if initial:
|
|
|
|
if alt_dir:
|
|
|
|
if old_packed != "":
|
|
|
|
_lwrite(packed_refs, old_packed)
|
|
|
|
else:
|
|
|
|
platform_utils.remove(packed_refs)
|
|
|
|
self.bare_git.pack_refs("--all", "--prune")
|
|
|
|
|
|
|
|
if is_sha1 and current_branch_only:
|
|
|
|
# We just synced the upstream given branch; verify we
|
|
|
|
# got what we wanted, else trigger a second run of all
|
|
|
|
# refs.
|
|
|
|
if not self._CheckForImmutableRevision():
|
|
|
|
# Sync the current branch only with depth set to None.
|
|
|
|
# We always pass depth=None down to avoid infinite recursion.
|
|
|
|
return self._RemoteFetch(
|
|
|
|
name=name,
|
|
|
|
quiet=quiet,
|
|
|
|
verbose=verbose,
|
|
|
|
output_redir=output_redir,
|
|
|
|
current_branch_only=current_branch_only and depth,
|
|
|
|
initial=False,
|
|
|
|
alt_dir=alt_dir,
|
2023-05-24 18:51:03 +00:00
|
|
|
tags=tags,
|
2023-03-11 06:46:20 +00:00
|
|
|
depth=None,
|
|
|
|
ssh_proxy=ssh_proxy,
|
|
|
|
clone_filter=clone_filter,
|
|
|
|
)
|
|
|
|
|
|
|
|
return ok
|
|
|
|
|
|
|
|
def _ApplyCloneBundle(self, initial=False, quiet=False, verbose=False):
|
|
|
|
if initial and (
|
|
|
|
self.manifest.manifestProject.depth or self.clone_depth
|
|
|
|
):
|
|
|
|
return False
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
remote = self.GetRemote()
|
|
|
|
bundle_url = remote.url + "/clone.bundle"
|
|
|
|
bundle_url = GitConfig.ForUser().UrlInsteadOf(bundle_url)
|
|
|
|
if GetSchemeFromUrl(bundle_url) not in (
|
|
|
|
"http",
|
|
|
|
"https",
|
|
|
|
"persistent-http",
|
|
|
|
"persistent-https",
|
|
|
|
):
|
|
|
|
return False
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
bundle_dst = os.path.join(self.gitdir, "clone.bundle")
|
|
|
|
bundle_tmp = os.path.join(self.gitdir, "clone.bundle.tmp")
|
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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
exist_dst = os.path.exists(bundle_dst)
|
|
|
|
exist_tmp = os.path.exists(bundle_tmp)
|
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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if not initial and not exist_dst and not exist_tmp:
|
|
|
|
return False
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if not exist_dst:
|
|
|
|
exist_dst = self._FetchBundle(
|
|
|
|
bundle_url, bundle_tmp, bundle_dst, quiet, verbose
|
|
|
|
)
|
|
|
|
if not exist_dst:
|
|
|
|
return False
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
cmd = ["fetch"]
|
|
|
|
if not verbose:
|
|
|
|
cmd.append("--quiet")
|
|
|
|
if not quiet and sys.stdout.isatty():
|
|
|
|
cmd.append("--progress")
|
|
|
|
if not self.worktree:
|
|
|
|
cmd.append("--update-head-ok")
|
|
|
|
cmd.append(bundle_dst)
|
|
|
|
for f in remote.fetch:
|
|
|
|
cmd.append(str(f))
|
|
|
|
cmd.append("+refs/tags/*:refs/tags/*")
|
|
|
|
|
|
|
|
ok = (
|
|
|
|
GitCommand(
|
|
|
|
self,
|
|
|
|
cmd,
|
|
|
|
bare=True,
|
|
|
|
objdir=os.path.join(self.objdir, "objects"),
|
|
|
|
).Wait()
|
|
|
|
== 0
|
|
|
|
)
|
|
|
|
platform_utils.remove(bundle_dst, missing_ok=True)
|
|
|
|
platform_utils.remove(bundle_tmp, missing_ok=True)
|
|
|
|
return ok
|
|
|
|
|
|
|
|
def _FetchBundle(self, srcUrl, tmpPath, dstPath, quiet, verbose):
|
|
|
|
platform_utils.remove(dstPath, missing_ok=True)
|
|
|
|
|
|
|
|
cmd = ["curl", "--fail", "--output", tmpPath, "--netrc", "--location"]
|
|
|
|
if quiet:
|
|
|
|
cmd += ["--silent", "--show-error"]
|
|
|
|
if os.path.exists(tmpPath):
|
|
|
|
size = os.stat(tmpPath).st_size
|
|
|
|
if size >= 1024:
|
|
|
|
cmd += ["--continue-at", "%d" % (size,)]
|
|
|
|
else:
|
|
|
|
platform_utils.remove(tmpPath)
|
|
|
|
with GetUrlCookieFile(srcUrl, quiet) as (cookiefile, proxy):
|
|
|
|
if cookiefile:
|
|
|
|
cmd += ["--cookie", cookiefile]
|
|
|
|
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") :]
|
|
|
|
cmd += [srcUrl]
|
|
|
|
|
|
|
|
proc = None
|
|
|
|
with Trace("Fetching bundle: %s", " ".join(cmd)):
|
|
|
|
if verbose:
|
2023-09-29 15:04:49 +00:00
|
|
|
print(f"{self.name}: Downloading bundle: {srcUrl}")
|
2023-03-11 06:46:20 +00:00
|
|
|
stdout = None if verbose else subprocess.PIPE
|
|
|
|
stderr = None if verbose else subprocess.STDOUT
|
|
|
|
try:
|
|
|
|
proc = subprocess.Popen(cmd, stdout=stdout, stderr=stderr)
|
|
|
|
except OSError:
|
|
|
|
return False
|
|
|
|
|
|
|
|
(output, _) = proc.communicate()
|
|
|
|
curlret = proc.returncode
|
|
|
|
|
|
|
|
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 verbose:
|
|
|
|
print(
|
|
|
|
"%s: Unable to retrieve clone.bundle; ignoring."
|
|
|
|
% self.name
|
|
|
|
)
|
|
|
|
if output:
|
|
|
|
print("Curl output:\n%s" % output)
|
|
|
|
return False
|
|
|
|
elif curlret and not verbose and output:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("%s", output)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
if os.path.exists(tmpPath):
|
|
|
|
if curlret == 0 and self._IsValidBundle(tmpPath, quiet):
|
|
|
|
platform_utils.rename(tmpPath, dstPath)
|
|
|
|
return True
|
|
|
|
else:
|
|
|
|
platform_utils.remove(tmpPath)
|
|
|
|
return False
|
|
|
|
else:
|
|
|
|
return 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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def _IsValidBundle(self, path, quiet):
|
|
|
|
try:
|
|
|
|
with open(path, "rb") as f:
|
|
|
|
if f.read(16) == b"# v2 git bundle\n":
|
|
|
|
return True
|
|
|
|
else:
|
|
|
|
if not quiet:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("Invalid clone.bundle file; ignoring.")
|
2023-03-11 06:46:20 +00:00
|
|
|
return False
|
|
|
|
except OSError:
|
|
|
|
return 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
|
|
|
|
2023-03-11 06:46:20 +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:
|
2023-07-14 23:45:35 +00:00
|
|
|
raise GitError(
|
2023-09-29 15:04:49 +00:00
|
|
|
f"{self.name} checkout {rev} ", project=self.name
|
2023-07-14 23:45:35 +00:00
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
def _CherryPick(self, rev, ffonly=False, record_origin=False):
|
|
|
|
cmd = ["cherry-pick"]
|
|
|
|
if ffonly:
|
|
|
|
cmd.append("--ff")
|
|
|
|
if record_origin:
|
|
|
|
cmd.append("-x")
|
|
|
|
cmd.append(rev)
|
|
|
|
cmd.append("--")
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
|
|
|
if self._allrefs:
|
2023-07-14 23:45:35 +00:00
|
|
|
raise GitError(
|
2023-09-29 15:04:49 +00:00
|
|
|
f"{self.name} cherry-pick {rev} ",
|
|
|
|
project=self.name,
|
2023-07-14 23:45:35 +00:00
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
def _LsRemote(self, refs):
|
|
|
|
cmd = ["ls-remote", self.remote.name, refs]
|
|
|
|
p = GitCommand(self, cmd, capture_stdout=True)
|
|
|
|
if p.Wait() == 0:
|
|
|
|
return p.stdout
|
|
|
|
return None
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def _Revert(self, rev):
|
|
|
|
cmd = ["revert"]
|
|
|
|
cmd.append("--no-edit")
|
|
|
|
cmd.append(rev)
|
|
|
|
cmd.append("--")
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
|
|
|
if self._allrefs:
|
2023-09-29 15:04:49 +00:00
|
|
|
raise GitError(f"{self.name} revert {rev} ", project=self.name)
|
2023-03-11 06:46:20 +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:
|
2023-07-14 23:45:35 +00:00
|
|
|
raise GitError(
|
2023-09-29 15:04:49 +00:00
|
|
|
f"{self.name} reset --hard {rev} ", project=self.name
|
2023-07-14 23:45:35 +00:00
|
|
|
)
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +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(
|
2023-07-14 23:45:35 +00:00
|
|
|
"%s submodule update --init --recursive " % self.name,
|
|
|
|
project=self.name,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
def _Rebase(self, upstream, onto=None):
|
|
|
|
cmd = ["rebase"]
|
|
|
|
if onto is not None:
|
|
|
|
cmd.extend(["--onto", onto])
|
|
|
|
cmd.append(upstream)
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
2023-09-29 15:04:49 +00:00
|
|
|
raise GitError(f"{self.name} rebase {upstream} ", project=self.name)
|
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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def _FastForward(self, head, ffonly=False):
|
|
|
|
cmd = ["merge", "--no-stat", head]
|
|
|
|
if ffonly:
|
|
|
|
cmd.append("--ff-only")
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
2023-09-29 15:04:49 +00:00
|
|
|
raise GitError(f"{self.name} merge {head} ", project=self.name)
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def _InitGitDir(self, mirror_git=None, force_sync=False, quiet=False):
|
|
|
|
init_git_dir = not os.path.exists(self.gitdir)
|
|
|
|
init_obj_dir = not os.path.exists(self.objdir)
|
|
|
|
try:
|
|
|
|
# Initialize the bare repository, which contains all of the objects.
|
|
|
|
if init_obj_dir:
|
|
|
|
os.makedirs(self.objdir)
|
|
|
|
self.bare_objdir.init()
|
|
|
|
|
|
|
|
self._UpdateHooks(quiet=quiet)
|
|
|
|
|
|
|
|
if self.use_git_worktrees:
|
|
|
|
# Enable per-worktree config file support if possible. This
|
|
|
|
# is more a nice-to-have feature for users rather than a
|
|
|
|
# hard requirement.
|
|
|
|
if git_require((2, 20, 0)):
|
|
|
|
self.EnableRepositoryExtension("worktreeConfig")
|
|
|
|
|
|
|
|
# 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)
|
|
|
|
|
|
|
|
if init_obj_dir or init_git_dir:
|
|
|
|
self._ReferenceGitDir(
|
|
|
|
self.objdir, self.gitdir, copy_all=True
|
|
|
|
)
|
|
|
|
try:
|
|
|
|
self._CheckDirReference(self.objdir, self.gitdir)
|
|
|
|
except GitError as e:
|
|
|
|
if force_sync:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
|
|
|
"Retrying clone after deleting %s", self.gitdir
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
try:
|
|
|
|
platform_utils.rmtree(
|
|
|
|
platform_utils.realpath(self.gitdir)
|
|
|
|
)
|
|
|
|
if self.worktree and os.path.exists(
|
|
|
|
platform_utils.realpath(self.worktree)
|
|
|
|
):
|
|
|
|
platform_utils.rmtree(
|
|
|
|
platform_utils.realpath(self.worktree)
|
|
|
|
)
|
|
|
|
return self._InitGitDir(
|
|
|
|
mirror_git=mirror_git,
|
|
|
|
force_sync=False,
|
|
|
|
quiet=quiet,
|
|
|
|
)
|
|
|
|
except Exception:
|
|
|
|
raise e
|
|
|
|
raise e
|
|
|
|
|
|
|
|
if init_git_dir:
|
|
|
|
mp = self.manifest.manifestProject
|
|
|
|
ref_dir = mp.reference or ""
|
|
|
|
|
|
|
|
def _expanded_ref_dirs():
|
|
|
|
"""Iterate through possible git reference dir paths."""
|
|
|
|
name = self.name + ".git"
|
|
|
|
yield mirror_git or os.path.join(ref_dir, name)
|
|
|
|
for prefix in "", self.remote.name:
|
|
|
|
yield os.path.join(
|
|
|
|
ref_dir, ".repo", "project-objects", prefix, name
|
|
|
|
)
|
|
|
|
yield os.path.join(
|
|
|
|
ref_dir, ".repo", "worktrees", prefix, name
|
|
|
|
)
|
|
|
|
|
|
|
|
if ref_dir or mirror_git:
|
|
|
|
found_ref_dir = None
|
|
|
|
for path in _expanded_ref_dirs():
|
|
|
|
if os.path.exists(path):
|
|
|
|
found_ref_dir = path
|
|
|
|
break
|
|
|
|
ref_dir = found_ref_dir
|
|
|
|
|
|
|
|
if ref_dir:
|
|
|
|
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")
|
|
|
|
)
|
|
|
|
_lwrite(
|
|
|
|
os.path.join(
|
|
|
|
self.objdir, "objects/info/alternates"
|
|
|
|
),
|
|
|
|
os.path.join(ref_dir, "objects") + "\n",
|
|
|
|
)
|
|
|
|
|
|
|
|
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))
|
|
|
|
if not self.manifest.EnableGitLfs:
|
|
|
|
self.config.SetString(
|
|
|
|
"filter.lfs.smudge", "git-lfs smudge --skip -- %f"
|
|
|
|
)
|
|
|
|
self.config.SetString(
|
|
|
|
"filter.lfs.process", "git-lfs filter-process --skip"
|
|
|
|
)
|
|
|
|
self.config.SetBoolean(
|
|
|
|
"core.bare", True if self.manifest.IsMirror else None
|
|
|
|
)
|
|
|
|
except Exception:
|
|
|
|
if init_obj_dir and os.path.exists(self.objdir):
|
|
|
|
platform_utils.rmtree(self.objdir)
|
|
|
|
if init_git_dir and os.path.exists(self.gitdir):
|
|
|
|
platform_utils.rmtree(self.gitdir)
|
|
|
|
raise
|
|
|
|
|
|
|
|
def _UpdateHooks(self, quiet=False):
|
|
|
|
if os.path.exists(self.objdir):
|
|
|
|
self._InitHooks(quiet=quiet)
|
|
|
|
|
|
|
|
def _InitHooks(self, quiet=False):
|
|
|
|
hooks = platform_utils.realpath(os.path.join(self.objdir, "hooks"))
|
|
|
|
if not os.path.exists(hooks):
|
|
|
|
os.makedirs(hooks)
|
|
|
|
|
|
|
|
# Delete sample hooks. They're noise.
|
|
|
|
for hook in glob.glob(os.path.join(hooks, "*.sample")):
|
|
|
|
try:
|
|
|
|
platform_utils.remove(hook, missing_ok=True)
|
|
|
|
except PermissionError:
|
|
|
|
pass
|
|
|
|
|
|
|
|
for stock_hook in _ProjectHooks():
|
|
|
|
name = os.path.basename(stock_hook)
|
|
|
|
|
|
|
|
if (
|
|
|
|
name in ("commit-msg",)
|
|
|
|
and not self.remote.review
|
|
|
|
and self is not self.manifest.manifestProject
|
|
|
|
):
|
|
|
|
# Don't install a Gerrit Code Review hook if this
|
|
|
|
# project does not appear to use it for reviews.
|
|
|
|
#
|
|
|
|
# Since the manifest project is one of those, but also
|
|
|
|
# managed through gerrit, it's excluded.
|
|
|
|
continue
|
|
|
|
|
|
|
|
dst = os.path.join(hooks, name)
|
|
|
|
if platform_utils.islink(dst):
|
|
|
|
continue
|
|
|
|
if os.path.exists(dst):
|
|
|
|
# If the files are the same, we'll leave it alone. We create
|
|
|
|
# symlinks below by default but fallback to hardlinks if the OS
|
|
|
|
# blocks them. So if we're here, it's probably because we made a
|
|
|
|
# hardlink below.
|
|
|
|
if not filecmp.cmp(stock_hook, dst, shallow=False):
|
|
|
|
if not quiet:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.warn(
|
|
|
|
"warn: %s: Not replacing locally modified %s hook",
|
2023-03-11 06:46:20 +00:00
|
|
|
self.RelPath(local=False),
|
|
|
|
name,
|
|
|
|
)
|
|
|
|
continue
|
|
|
|
try:
|
|
|
|
platform_utils.symlink(
|
|
|
|
os.path.relpath(stock_hook, os.path.dirname(dst)), dst
|
|
|
|
)
|
|
|
|
except OSError as e:
|
|
|
|
if e.errno == errno.EPERM:
|
|
|
|
try:
|
|
|
|
os.link(stock_hook, dst)
|
|
|
|
except OSError:
|
2023-07-14 23:45:35 +00:00
|
|
|
raise GitError(
|
|
|
|
self._get_symlink_error_message(), project=self.name
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
else:
|
|
|
|
raise
|
|
|
|
|
|
|
|
def _InitRemote(self):
|
|
|
|
if self.remote.url:
|
|
|
|
remote = self.GetRemote()
|
|
|
|
remote.url = self.remote.url
|
|
|
|
remote.pushUrl = self.remote.pushUrl
|
|
|
|
remote.review = self.remote.review
|
|
|
|
remote.projectname = self.name
|
|
|
|
|
|
|
|
if self.worktree:
|
|
|
|
remote.ResetFetch(mirror=False)
|
|
|
|
else:
|
|
|
|
remote.ResetFetch(mirror=True)
|
|
|
|
remote.Save()
|
|
|
|
|
|
|
|
def _InitMRef(self):
|
|
|
|
"""Initialize the pseudo m/<manifest branch> ref."""
|
|
|
|
if self.manifest.branch:
|
|
|
|
if self.use_git_worktrees:
|
|
|
|
# Set up the m/ space to point to the worktree-specific ref
|
|
|
|
# space. We'll update the worktree-specific ref space on each
|
|
|
|
# checkout.
|
|
|
|
ref = R_M + self.manifest.branch
|
|
|
|
if not self.bare_ref.symref(ref):
|
|
|
|
self.bare_git.symbolic_ref(
|
|
|
|
"-m",
|
|
|
|
"redirecting to worktree scope",
|
|
|
|
ref,
|
|
|
|
R_WORKTREE_M + self.manifest.branch,
|
|
|
|
)
|
|
|
|
|
|
|
|
# We can't update this ref with git worktrees until it exists.
|
|
|
|
# We'll wait until the initial checkout to set it.
|
|
|
|
if not os.path.exists(self.worktree):
|
|
|
|
return
|
|
|
|
|
|
|
|
base = R_WORKTREE_M
|
|
|
|
active_git = self.work_git
|
|
|
|
|
|
|
|
self._InitAnyMRef(HEAD, self.bare_git, detach=True)
|
|
|
|
else:
|
|
|
|
base = R_M
|
|
|
|
active_git = self.bare_git
|
|
|
|
|
|
|
|
self._InitAnyMRef(base + self.manifest.branch, active_git)
|
|
|
|
|
|
|
|
def _InitMirrorHead(self):
|
|
|
|
self._InitAnyMRef(HEAD, self.bare_git)
|
|
|
|
|
|
|
|
def _InitAnyMRef(self, ref, active_git, detach=False):
|
|
|
|
"""Initialize |ref| in |active_git| to the value in the manifest.
|
|
|
|
|
|
|
|
This points |ref| to the <project> setting in the manifest.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
ref: The branch to update.
|
|
|
|
active_git: The git repository to make updates in.
|
|
|
|
detach: Whether to update target of symbolic refs, or overwrite the
|
|
|
|
ref directly (and thus make it non-symbolic).
|
|
|
|
"""
|
|
|
|
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"
|
|
|
|
active_git.UpdateRef(ref, dst, message=msg, detach=True)
|
|
|
|
else:
|
|
|
|
remote = self.GetRemote()
|
|
|
|
dst = remote.ToLocal(self.revisionExpr)
|
|
|
|
if cur != dst:
|
|
|
|
msg = "manifest set to %s" % self.revisionExpr
|
|
|
|
if detach:
|
|
|
|
active_git.UpdateRef(ref, dst, message=msg, detach=True)
|
|
|
|
else:
|
|
|
|
active_git.symbolic_ref("-m", msg, ref, dst)
|
|
|
|
|
|
|
|
def _CheckDirReference(self, srcdir, destdir):
|
|
|
|
# Git worktrees don't use symlinks to share at all.
|
|
|
|
if self.use_git_worktrees:
|
|
|
|
return
|
|
|
|
|
|
|
|
for name in self.shareable_dirs:
|
|
|
|
# Try to self-heal a bit in simple cases.
|
|
|
|
dst_path = os.path.join(destdir, name)
|
|
|
|
src_path = os.path.join(srcdir, name)
|
|
|
|
|
|
|
|
dst = platform_utils.realpath(dst_path)
|
|
|
|
if os.path.lexists(dst):
|
|
|
|
src = platform_utils.realpath(src_path)
|
|
|
|
# Fail if the links are pointing to the wrong place.
|
|
|
|
if src != dst:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
|
|
|
"error: %s is different in %s vs %s",
|
|
|
|
name,
|
|
|
|
destdir,
|
|
|
|
srcdir,
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
raise GitError(
|
|
|
|
"--force-sync not enabled; cannot overwrite a local "
|
|
|
|
"work tree. If you're comfortable with the "
|
|
|
|
"possibility of losing the work tree's git metadata,"
|
2023-09-29 15:04:49 +00:00
|
|
|
" use `repo sync --force-sync {}` to "
|
2023-07-14 23:45:35 +00:00
|
|
|
"proceed.".format(self.RelPath(local=False)),
|
|
|
|
project=self.name,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
def _ReferenceGitDir(self, gitdir, dotgit, 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.
|
|
|
|
copy_all: If true, copy all remaining files from |gitdir| ->
|
|
|
|
|dotgit|. This saves you the effort of initializing |dotgit|
|
|
|
|
yourself.
|
|
|
|
"""
|
|
|
|
symlink_dirs = self.shareable_dirs[:]
|
|
|
|
to_symlink = symlink_dirs
|
|
|
|
|
|
|
|
to_copy = []
|
|
|
|
if copy_all:
|
|
|
|
to_copy = platform_utils.listdir(gitdir)
|
|
|
|
|
|
|
|
dotgit = platform_utils.realpath(dotgit)
|
|
|
|
for name in set(to_copy).union(to_symlink):
|
|
|
|
try:
|
|
|
|
src = platform_utils.realpath(os.path.join(gitdir, name))
|
|
|
|
dst = os.path.join(dotgit, name)
|
|
|
|
|
|
|
|
if os.path.lexists(dst):
|
|
|
|
continue
|
|
|
|
|
|
|
|
# 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)
|
|
|
|
|
|
|
|
if name in to_symlink:
|
|
|
|
platform_utils.symlink(
|
|
|
|
os.path.relpath(src, os.path.dirname(dst)), dst
|
|
|
|
)
|
|
|
|
elif copy_all and not platform_utils.islink(dst):
|
|
|
|
if platform_utils.isdir(src):
|
|
|
|
shutil.copytree(src, dst)
|
|
|
|
elif os.path.isfile(src):
|
|
|
|
shutil.copy(src, dst)
|
|
|
|
|
|
|
|
except OSError as e:
|
|
|
|
if e.errno == errno.EPERM:
|
|
|
|
raise DownloadError(self._get_symlink_error_message())
|
|
|
|
else:
|
|
|
|
raise
|
|
|
|
|
|
|
|
def _InitGitWorktree(self):
|
|
|
|
"""Init the project using git worktrees."""
|
|
|
|
self.bare_git.worktree("prune")
|
|
|
|
self.bare_git.worktree(
|
|
|
|
"add",
|
|
|
|
"-ff",
|
|
|
|
"--checkout",
|
|
|
|
"--detach",
|
|
|
|
"--lock",
|
|
|
|
self.worktree,
|
|
|
|
self.GetRevisionId(),
|
|
|
|
)
|
2016-02-10 17:44:30 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
# Rewrite the internal state files to use relative paths between the
|
|
|
|
# checkouts & worktrees.
|
|
|
|
dotgit = os.path.join(self.worktree, ".git")
|
2023-09-29 15:04:49 +00:00
|
|
|
with open(dotgit) as fp:
|
2023-03-11 06:46:20 +00:00
|
|
|
# Figure out the checkout->worktree path.
|
|
|
|
setting = fp.read()
|
|
|
|
assert setting.startswith("gitdir:")
|
|
|
|
git_worktree_path = setting.split(":", 1)[1].strip()
|
|
|
|
# Some platforms (e.g. Windows) won't let us update dotgit in situ
|
|
|
|
# because of file permissions. Delete it and recreate it from scratch
|
|
|
|
# to avoid.
|
|
|
|
platform_utils.remove(dotgit)
|
|
|
|
# Use relative path from checkout->worktree & maintain Unix line endings
|
|
|
|
# on all OS's to match git behavior.
|
|
|
|
with open(dotgit, "w", newline="\n") as fp:
|
|
|
|
print(
|
|
|
|
"gitdir:",
|
|
|
|
os.path.relpath(git_worktree_path, self.worktree),
|
|
|
|
file=fp,
|
|
|
|
)
|
|
|
|
# Use relative path from worktree->checkout & maintain Unix line endings
|
|
|
|
# on all OS's to match git behavior.
|
|
|
|
with open(
|
|
|
|
os.path.join(git_worktree_path, "gitdir"), "w", newline="\n"
|
|
|
|
) as fp:
|
|
|
|
print(os.path.relpath(dotgit, git_worktree_path), file=fp)
|
|
|
|
|
|
|
|
self._InitMRef()
|
|
|
|
|
|
|
|
def _InitWorkTree(self, force_sync=False, submodules=False):
|
|
|
|
"""Setup the worktree .git path.
|
|
|
|
|
|
|
|
This is the user-visible path like src/foo/.git/.
|
|
|
|
|
|
|
|
With non-git-worktrees, this will be a symlink to the .repo/projects/
|
|
|
|
path. With git-worktrees, this will be a .git file using "gitdir: ..."
|
|
|
|
syntax.
|
|
|
|
|
|
|
|
Older checkouts had .git/ directories. If we see that, migrate it.
|
|
|
|
|
|
|
|
This also handles changes in the manifest. Maybe this project was
|
|
|
|
backed by "foo/bar" on the server, but now it's "new/foo/bar". We have
|
|
|
|
to update the path we point to under .repo/projects/ to match.
|
|
|
|
"""
|
|
|
|
dotgit = os.path.join(self.worktree, ".git")
|
|
|
|
|
|
|
|
# If using an old layout style (a directory), migrate it.
|
|
|
|
if not platform_utils.islink(dotgit) and platform_utils.isdir(dotgit):
|
2023-07-14 23:45:35 +00:00
|
|
|
self._MigrateOldWorkTreeGitDir(dotgit, project=self.name)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
init_dotgit = not os.path.exists(dotgit)
|
|
|
|
if self.use_git_worktrees:
|
|
|
|
if init_dotgit:
|
|
|
|
self._InitGitWorktree()
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
else:
|
|
|
|
if not init_dotgit:
|
|
|
|
# See if the project has changed.
|
|
|
|
if platform_utils.realpath(
|
|
|
|
self.gitdir
|
|
|
|
) != platform_utils.realpath(dotgit):
|
|
|
|
platform_utils.remove(dotgit)
|
|
|
|
|
|
|
|
if init_dotgit or not os.path.exists(dotgit):
|
|
|
|
os.makedirs(self.worktree, exist_ok=True)
|
|
|
|
platform_utils.symlink(
|
|
|
|
os.path.relpath(self.gitdir, self.worktree), dotgit
|
|
|
|
)
|
|
|
|
|
|
|
|
if init_dotgit:
|
|
|
|
_lwrite(
|
|
|
|
os.path.join(dotgit, HEAD), "%s\n" % self.GetRevisionId()
|
|
|
|
)
|
|
|
|
|
|
|
|
# Finish checking out the worktree.
|
|
|
|
cmd = ["read-tree", "--reset", "-u", "-v", HEAD]
|
|
|
|
if GitCommand(self, cmd).Wait() != 0:
|
|
|
|
raise GitError(
|
2023-07-14 23:45:35 +00:00
|
|
|
"Cannot initialize work tree for " + self.name,
|
|
|
|
project=self.name,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
if submodules:
|
|
|
|
self._SyncSubmodules(quiet=True)
|
|
|
|
self._CopyAndLinkFiles()
|
|
|
|
|
|
|
|
@classmethod
|
2023-07-14 23:45:35 +00:00
|
|
|
def _MigrateOldWorkTreeGitDir(cls, dotgit, project=None):
|
2023-03-11 06:46:20 +00:00
|
|
|
"""Migrate the old worktree .git/ dir style to a symlink.
|
|
|
|
|
|
|
|
This logic specifically only uses state from |dotgit| to figure out
|
|
|
|
where to move content and not |self|. This way if the backing project
|
|
|
|
also changed places, we only do the .git/ dir to .git symlink migration
|
|
|
|
here. The path updates will happen independently.
|
|
|
|
"""
|
|
|
|
# Figure out where in .repo/projects/ it's pointing to.
|
|
|
|
if not os.path.islink(os.path.join(dotgit, "refs")):
|
2023-07-14 23:45:35 +00:00
|
|
|
raise GitError(
|
|
|
|
f"{dotgit}: unsupported checkout state", project=project
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
gitdir = os.path.dirname(os.path.realpath(os.path.join(dotgit, "refs")))
|
|
|
|
|
|
|
|
# Remove known symlink paths that exist in .repo/projects/.
|
|
|
|
KNOWN_LINKS = {
|
|
|
|
"config",
|
|
|
|
"description",
|
|
|
|
"hooks",
|
|
|
|
"info",
|
|
|
|
"logs",
|
|
|
|
"objects",
|
|
|
|
"packed-refs",
|
|
|
|
"refs",
|
|
|
|
"rr-cache",
|
|
|
|
"shallow",
|
|
|
|
"svn",
|
|
|
|
}
|
|
|
|
# Paths that we know will be in both, but are safe to clobber in
|
|
|
|
# .repo/projects/.
|
|
|
|
SAFE_TO_CLOBBER = {
|
|
|
|
"COMMIT_EDITMSG",
|
|
|
|
"FETCH_HEAD",
|
|
|
|
"HEAD",
|
|
|
|
"gc.log",
|
|
|
|
"gitk.cache",
|
|
|
|
"index",
|
|
|
|
"ORIG_HEAD",
|
|
|
|
}
|
|
|
|
|
|
|
|
# First see if we'd succeed before starting the migration.
|
|
|
|
unknown_paths = []
|
|
|
|
for name in platform_utils.listdir(dotgit):
|
|
|
|
# Ignore all temporary/backup names. These are common with vim &
|
|
|
|
# emacs.
|
|
|
|
if name.endswith("~") or (name[0] == "#" and name[-1] == "#"):
|
|
|
|
continue
|
|
|
|
|
|
|
|
dotgit_path = os.path.join(dotgit, name)
|
|
|
|
if name in KNOWN_LINKS:
|
|
|
|
if not platform_utils.islink(dotgit_path):
|
|
|
|
unknown_paths.append(f"{dotgit_path}: should be a symlink")
|
|
|
|
else:
|
|
|
|
gitdir_path = os.path.join(gitdir, name)
|
|
|
|
if name not in SAFE_TO_CLOBBER and os.path.exists(gitdir_path):
|
|
|
|
unknown_paths.append(
|
|
|
|
f"{dotgit_path}: unknown file; please file a bug"
|
|
|
|
)
|
|
|
|
if unknown_paths:
|
2023-07-14 23:45:35 +00:00
|
|
|
raise GitError(
|
|
|
|
"Aborting migration: " + "\n".join(unknown_paths),
|
|
|
|
project=project,
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
# Now walk the paths and sync the .git/ to .repo/projects/.
|
|
|
|
for name in platform_utils.listdir(dotgit):
|
|
|
|
dotgit_path = os.path.join(dotgit, name)
|
|
|
|
|
|
|
|
# Ignore all temporary/backup names. These are common with vim &
|
|
|
|
# emacs.
|
|
|
|
if name.endswith("~") or (name[0] == "#" and name[-1] == "#"):
|
|
|
|
platform_utils.remove(dotgit_path)
|
|
|
|
elif name in KNOWN_LINKS:
|
|
|
|
platform_utils.remove(dotgit_path)
|
|
|
|
else:
|
|
|
|
gitdir_path = os.path.join(gitdir, name)
|
|
|
|
platform_utils.remove(gitdir_path, missing_ok=True)
|
|
|
|
platform_utils.rename(dotgit_path, gitdir_path)
|
|
|
|
|
|
|
|
# Now that the dir should be empty, clear it out, and symlink it over.
|
|
|
|
platform_utils.rmdir(dotgit)
|
|
|
|
platform_utils.symlink(
|
2023-09-29 16:42:22 +00:00
|
|
|
os.path.relpath(gitdir, os.path.dirname(os.path.realpath(dotgit))),
|
|
|
|
dotgit,
|
2023-03-11 06:46:20 +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
|
|
|
|
2023-03-11 06:46:20 +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"
|
|
|
|
|
|
|
|
def _revlist(self, *args, **kw):
|
|
|
|
a = []
|
|
|
|
a.extend(args)
|
|
|
|
a.append("--")
|
|
|
|
return self.work_git.rev_list(*a, **kw)
|
|
|
|
|
|
|
|
@property
|
|
|
|
def _allrefs(self):
|
|
|
|
return self.bare_ref.all
|
|
|
|
|
|
|
|
def _getLogs(
|
|
|
|
self, rev1, rev2, oneline=False, color=True, pretty_format=None
|
|
|
|
):
|
|
|
|
"""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")
|
|
|
|
if pretty_format is not None:
|
|
|
|
cmd.append("--pretty=format:%s" % pretty_format)
|
|
|
|
if oneline:
|
|
|
|
cmd.append("--oneline")
|
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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
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
|
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
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def getAddedAndRemovedLogs(
|
|
|
|
self, toProject, oneline=False, color=True, pretty_format=None
|
|
|
|
):
|
|
|
|
"""Get the list of logs from this revision to given revisionId"""
|
|
|
|
logs = {}
|
|
|
|
selfId = self.GetRevisionId(self._allrefs)
|
|
|
|
toId = toProject.GetRevisionId(toProject._allrefs)
|
|
|
|
|
|
|
|
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,
|
|
|
|
)
|
|
|
|
return logs
|
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class _GitGetByExec:
|
2023-03-11 06:46:20 +00:00
|
|
|
def __init__(self, project, bare, gitdir):
|
|
|
|
self._project = project
|
|
|
|
self._bare = bare
|
|
|
|
self._gitdir = gitdir
|
|
|
|
|
|
|
|
# __getstate__ and __setstate__ are required for pickling because
|
|
|
|
# __getattr__ exists.
|
|
|
|
def __getstate__(self):
|
|
|
|
return (self._project, self._bare, self._gitdir)
|
|
|
|
|
|
|
|
def __setstate__(self, state):
|
|
|
|
self._project, self._bare, self._gitdir = state
|
|
|
|
|
|
|
|
def LsOthers(self):
|
|
|
|
p = GitCommand(
|
|
|
|
self._project,
|
|
|
|
["ls-files", "-z", "--others", "--exclude-standard"],
|
|
|
|
bare=False,
|
|
|
|
gitdir=self._gitdir,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
|
|
|
)
|
|
|
|
if p.Wait() == 0:
|
|
|
|
out = p.stdout
|
|
|
|
if out:
|
|
|
|
# Backslash is not anomalous.
|
|
|
|
return out[:-1].split("\0")
|
|
|
|
return []
|
|
|
|
|
|
|
|
def DiffZ(self, name, *args):
|
|
|
|
cmd = [name]
|
|
|
|
cmd.append("-z")
|
|
|
|
cmd.append("--ignore-submodules")
|
|
|
|
cmd.extend(args)
|
|
|
|
p = GitCommand(
|
|
|
|
self._project,
|
|
|
|
cmd,
|
|
|
|
gitdir=self._gitdir,
|
|
|
|
bare=False,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
|
|
|
)
|
|
|
|
p.Wait()
|
|
|
|
r = {}
|
|
|
|
out = p.stdout
|
|
|
|
if out:
|
|
|
|
out = iter(out[:-1].split("\0"))
|
|
|
|
while out:
|
|
|
|
try:
|
|
|
|
info = next(out)
|
|
|
|
path = next(out)
|
|
|
|
except StopIteration:
|
|
|
|
break
|
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class _Info:
|
2023-03-11 06:46:20 +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(" ")
|
|
|
|
info = _Info(path, *info)
|
|
|
|
if info.status in ("R", "C"):
|
|
|
|
info.src_path = info.path
|
|
|
|
info.path = next(out)
|
|
|
|
r[info.path] = info
|
|
|
|
return r
|
|
|
|
|
|
|
|
def GetDotgitPath(self, subpath=None):
|
|
|
|
"""Return the full path to the .git dir.
|
|
|
|
|
|
|
|
As a convenience, append |subpath| if provided.
|
|
|
|
"""
|
|
|
|
if self._bare:
|
|
|
|
dotgit = self._gitdir
|
|
|
|
else:
|
|
|
|
dotgit = os.path.join(self._project.worktree, ".git")
|
|
|
|
if os.path.isfile(dotgit):
|
|
|
|
# Git worktrees use a "gitdir:" syntax to point to the
|
|
|
|
# scratch space.
|
|
|
|
with open(dotgit) as fp:
|
|
|
|
setting = fp.read()
|
|
|
|
assert setting.startswith("gitdir:")
|
|
|
|
gitdir = setting.split(":", 1)[1].strip()
|
|
|
|
dotgit = os.path.normpath(
|
|
|
|
os.path.join(self._project.worktree, gitdir)
|
|
|
|
)
|
|
|
|
|
|
|
|
return dotgit if subpath is None else os.path.join(dotgit, subpath)
|
|
|
|
|
|
|
|
def GetHead(self):
|
|
|
|
"""Return the ref that HEAD points to."""
|
|
|
|
path = self.GetDotgitPath(subpath=HEAD)
|
|
|
|
try:
|
|
|
|
with open(path) as fd:
|
|
|
|
line = fd.readline()
|
2023-09-29 15:04:49 +00:00
|
|
|
except OSError as e:
|
2023-03-11 06:46:20 +00:00
|
|
|
raise NoManifestException(path, str(e))
|
|
|
|
try:
|
|
|
|
line = line.decode()
|
|
|
|
except AttributeError:
|
|
|
|
pass
|
|
|
|
if line.startswith("ref: "):
|
|
|
|
return line[5:-1]
|
|
|
|
return line[:-1]
|
|
|
|
|
|
|
|
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)
|
|
|
|
self._project.bare_ref.deleted(name)
|
|
|
|
|
2023-09-27 18:34:43 +00:00
|
|
|
def rev_list(self, *args, log_as_error=True, **kw):
|
2023-03-11 06:46:20 +00:00
|
|
|
if "format" in kw:
|
|
|
|
cmdv = ["log", "--pretty=format:%s" % kw["format"]]
|
|
|
|
else:
|
|
|
|
cmdv = ["rev-list"]
|
|
|
|
cmdv.extend(args)
|
|
|
|
p = GitCommand(
|
|
|
|
self._project,
|
|
|
|
cmdv,
|
|
|
|
bare=self._bare,
|
|
|
|
gitdir=self._gitdir,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
2023-07-14 23:45:35 +00:00
|
|
|
verify_command=True,
|
2023-09-27 18:34:43 +00:00
|
|
|
log_as_error=log_as_error,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
2023-07-14 23:45:35 +00:00
|
|
|
p.Wait()
|
2023-03-11 06:46:20 +00:00
|
|
|
return p.stdout.splitlines()
|
|
|
|
|
|
|
|
def __getattr__(self, name):
|
|
|
|
"""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. 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'.
|
|
|
|
|
|
|
|
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.
|
|
|
|
"""
|
|
|
|
name = name.replace("_", "-")
|
|
|
|
|
2023-09-27 18:34:43 +00:00
|
|
|
def runner(*args, log_as_error=True, **kwargs):
|
2023-03-11 06:46:20 +00:00
|
|
|
cmdv = []
|
|
|
|
config = kwargs.pop("config", None)
|
|
|
|
for k in kwargs:
|
|
|
|
raise TypeError(
|
2023-09-29 15:04:49 +00:00
|
|
|
"{}() got an unexpected keyword argument {!r}".format(
|
|
|
|
name, k
|
|
|
|
)
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
if config is not None:
|
|
|
|
for k, v in config.items():
|
|
|
|
cmdv.append("-c")
|
2023-09-29 15:04:49 +00:00
|
|
|
cmdv.append(f"{k}={v}")
|
2023-03-11 06:46:20 +00:00
|
|
|
cmdv.append(name)
|
|
|
|
cmdv.extend(args)
|
|
|
|
p = GitCommand(
|
|
|
|
self._project,
|
|
|
|
cmdv,
|
|
|
|
bare=self._bare,
|
|
|
|
gitdir=self._gitdir,
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
2023-07-14 23:45:35 +00:00
|
|
|
verify_command=True,
|
2023-09-27 18:34:43 +00:00
|
|
|
log_as_error=log_as_error,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
2023-07-14 23:45:35 +00:00
|
|
|
p.Wait()
|
2023-03-11 06:46:20 +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
|
|
|
|
|
|
|
|
2023-07-14 23:45:35 +00:00
|
|
|
class LocalSyncFail(RepoError):
|
|
|
|
"""Default error when there is an Sync_LocalHalf error."""
|
|
|
|
|
|
|
|
|
|
|
|
class _PriorSyncFailedError(LocalSyncFail):
|
2023-03-11 06:46:20 +00:00
|
|
|
def __str__(self):
|
|
|
|
return "prior sync failed; rebase still in progress"
|
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
|
|
|
|
|
|
|
|
2023-07-14 23:45:35 +00:00
|
|
|
class _DirtyError(LocalSyncFail):
|
2023-03-11 06:46:20 +00:00
|
|
|
def __str__(self):
|
|
|
|
return "contains uncommitted 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
|
|
|
|
2017-04-05 07:02:59 +00:00
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class _InfoMessage:
|
2023-03-11 06:46:20 +00:00
|
|
|
def __init__(self, project, text):
|
|
|
|
self.project = project
|
|
|
|
self.text = text
|
2017-04-05 07:02:59 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def Print(self, syncbuf):
|
|
|
|
syncbuf.out.info(
|
|
|
|
"%s/: %s", self.project.RelPath(local=False), self.text
|
|
|
|
)
|
|
|
|
syncbuf.out.nl()
|
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
|
|
|
|
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class _Failure:
|
2023-03-11 06:46:20 +00:00
|
|
|
def __init__(self, project, why):
|
|
|
|
self.project = project
|
|
|
|
self.why = why
|
2019-08-26 19:22:36 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def Print(self, syncbuf):
|
|
|
|
syncbuf.out.fail(
|
|
|
|
"error: %s/: %s", self.project.RelPath(local=False), str(self.why)
|
|
|
|
)
|
|
|
|
syncbuf.out.nl()
|
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
|
|
|
|
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class _Later:
|
2023-03-11 06:46:20 +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(local=False))
|
|
|
|
out.nl()
|
|
|
|
try:
|
|
|
|
self.action()
|
|
|
|
out.nl()
|
|
|
|
return True
|
|
|
|
except GitError:
|
|
|
|
out.nl()
|
|
|
|
return 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
|
|
|
|
2022-03-29 21:54:22 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
class _SyncColoring(Coloring):
|
|
|
|
def __init__(self, config):
|
|
|
|
super().__init__(config, "reposync")
|
|
|
|
self.project = self.printer("header", attr="bold")
|
|
|
|
self.info = self.printer("info")
|
|
|
|
self.fail = self.printer("fail", fg="red")
|
2022-03-29 21:54:22 +00:00
|
|
|
|
|
|
|
|
2023-09-29 15:04:49 +00:00
|
|
|
class SyncBuffer:
|
2023-03-11 06:46:20 +00:00
|
|
|
def __init__(self, config, detach_head=False):
|
|
|
|
self._messages = []
|
|
|
|
self._failures = []
|
|
|
|
self._later_queue1 = []
|
|
|
|
self._later_queue2 = []
|
2022-03-29 21:54:22 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
self.out = _SyncColoring(config)
|
|
|
|
self.out.redirect(sys.stderr)
|
2023-01-05 17:57:31 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
self.detach_head = detach_head
|
|
|
|
self.clean = True
|
|
|
|
self.recent_clean = True
|
2022-03-29 23:01:18 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def info(self, project, fmt, *args):
|
|
|
|
self._messages.append(_InfoMessage(project, fmt % args))
|
2022-03-29 23:01:18 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def fail(self, project, err=None):
|
|
|
|
self._failures.append(_Failure(project, err))
|
|
|
|
self._MarkUnclean()
|
2022-03-29 23:01:18 +00:00
|
|
|
|
2023-03-11 06:46:20 +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
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
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):
|
|
|
|
self._MarkUnclean()
|
|
|
|
return False
|
|
|
|
setattr(self, queue, [])
|
|
|
|
return True
|
|
|
|
|
|
|
|
def _PrintMessages(self):
|
|
|
|
if self._messages or self._failures:
|
|
|
|
if os.isatty(2):
|
|
|
|
self.out.write(progress.CSI_ERASE_LINE)
|
|
|
|
self.out.write("\r")
|
|
|
|
|
|
|
|
for m in self._messages:
|
|
|
|
m.Print(self)
|
|
|
|
for m in self._failures:
|
|
|
|
m.Print(self)
|
|
|
|
|
|
|
|
self._messages = []
|
|
|
|
self._failures = []
|
|
|
|
|
|
|
|
|
|
|
|
class MetaProject(Project):
|
|
|
|
"""A special project housed under .repo."""
|
|
|
|
|
|
|
|
def __init__(self, manifest, name, gitdir, worktree):
|
|
|
|
Project.__init__(
|
|
|
|
self,
|
|
|
|
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,
|
|
|
|
)
|
|
|
|
|
|
|
|
def PreSync(self):
|
|
|
|
if self.Exists:
|
|
|
|
cb = self.CurrentBranch
|
|
|
|
if cb:
|
|
|
|
base = self.GetBranch(cb).merge
|
|
|
|
if base:
|
|
|
|
self.revisionExpr = base
|
|
|
|
self.revisionId = None
|
|
|
|
|
|
|
|
@property
|
|
|
|
def HasChanges(self):
|
|
|
|
"""Has the remote received new commits not yet checked out?"""
|
|
|
|
if not self.remote or not self.revisionExpr:
|
2022-03-29 23:01:18 +00:00
|
|
|
return False
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
all_refs = self.bare_ref.all
|
|
|
|
revid = self.GetRevisionId(all_refs)
|
|
|
|
head = self.work_git.GetHead()
|
|
|
|
if head.startswith(R_HEADS):
|
|
|
|
try:
|
|
|
|
head = all_refs[head]
|
|
|
|
except KeyError:
|
|
|
|
head = None
|
2022-03-29 23:01:18 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if revid == head:
|
|
|
|
return False
|
|
|
|
elif self._revlist(not_rev(HEAD), revid):
|
|
|
|
return True
|
2022-04-27 17:34:42 +00:00
|
|
|
return False
|
2022-03-29 23:01:18 +00:00
|
|
|
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
class RepoProject(MetaProject):
|
|
|
|
"""The MetaProject for repo itself."""
|
2022-03-29 23:01:18 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
@property
|
|
|
|
def LastFetch(self):
|
|
|
|
try:
|
|
|
|
fh = os.path.join(self.gitdir, "FETCH_HEAD")
|
|
|
|
return os.path.getmtime(fh)
|
|
|
|
except OSError:
|
|
|
|
return 0
|
2022-03-29 23:01:18 +00:00
|
|
|
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
class ManifestProject(MetaProject):
|
|
|
|
"""The MetaProject for manifests."""
|
|
|
|
|
|
|
|
def MetaBranchSwitch(self, submodules=False):
|
|
|
|
"""Prepare for manifest branch switch."""
|
|
|
|
|
|
|
|
# detach and delete manifest branch, allowing a new
|
|
|
|
# branch to take over
|
|
|
|
syncbuf = SyncBuffer(self.config, detach_head=True)
|
|
|
|
self.Sync_LocalHalf(syncbuf, submodules=submodules)
|
|
|
|
syncbuf.Finish()
|
|
|
|
|
|
|
|
return (
|
|
|
|
GitCommand(
|
|
|
|
self,
|
|
|
|
["update-ref", "-d", "refs/heads/default"],
|
|
|
|
capture_stdout=True,
|
|
|
|
capture_stderr=True,
|
|
|
|
).Wait()
|
|
|
|
== 0
|
|
|
|
)
|
|
|
|
|
|
|
|
@property
|
|
|
|
def standalone_manifest_url(self):
|
|
|
|
"""The URL of the standalone manifest, or None."""
|
|
|
|
return self.config.GetString("manifest.standalone")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def manifest_groups(self):
|
|
|
|
"""The manifest groups string."""
|
|
|
|
return self.config.GetString("manifest.groups")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def reference(self):
|
|
|
|
"""The --reference for this manifest."""
|
|
|
|
return self.config.GetString("repo.reference")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def dissociate(self):
|
|
|
|
"""Whether to dissociate."""
|
|
|
|
return self.config.GetBoolean("repo.dissociate")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def archive(self):
|
|
|
|
"""Whether we use archive."""
|
|
|
|
return self.config.GetBoolean("repo.archive")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def mirror(self):
|
|
|
|
"""Whether we use mirror."""
|
|
|
|
return self.config.GetBoolean("repo.mirror")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def use_worktree(self):
|
|
|
|
"""Whether we use worktree."""
|
|
|
|
return self.config.GetBoolean("repo.worktree")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def clone_bundle(self):
|
|
|
|
"""Whether we use clone_bundle."""
|
|
|
|
return self.config.GetBoolean("repo.clonebundle")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def submodules(self):
|
|
|
|
"""Whether we use submodules."""
|
|
|
|
return self.config.GetBoolean("repo.submodules")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def git_lfs(self):
|
|
|
|
"""Whether we use git_lfs."""
|
|
|
|
return self.config.GetBoolean("repo.git-lfs")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def use_superproject(self):
|
|
|
|
"""Whether we use superproject."""
|
|
|
|
return self.config.GetBoolean("repo.superproject")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def partial_clone(self):
|
|
|
|
"""Whether this is a partial clone."""
|
|
|
|
return self.config.GetBoolean("repo.partialclone")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def depth(self):
|
|
|
|
"""Partial clone depth."""
|
|
|
|
return self.config.GetString("repo.depth")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def clone_filter(self):
|
|
|
|
"""The clone filter."""
|
|
|
|
return self.config.GetString("repo.clonefilter")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def partial_clone_exclude(self):
|
|
|
|
"""Partial clone exclude string"""
|
|
|
|
return self.config.GetString("repo.partialcloneexclude")
|
|
|
|
|
2023-05-23 20:06:55 +00:00
|
|
|
@property
|
|
|
|
def clone_filter_for_depth(self):
|
|
|
|
"""Replace shallow clone with partial clone."""
|
|
|
|
return self.config.GetString("repo.clonefilterfordepth")
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
@property
|
|
|
|
def manifest_platform(self):
|
|
|
|
"""The --platform argument from `repo init`."""
|
|
|
|
return self.config.GetString("manifest.platform")
|
|
|
|
|
|
|
|
@property
|
|
|
|
def _platform_name(self):
|
|
|
|
"""Return the name of the platform."""
|
|
|
|
return platform.system().lower()
|
|
|
|
|
|
|
|
def SyncWithPossibleInit(
|
|
|
|
self,
|
|
|
|
submanifest,
|
|
|
|
verbose=False,
|
|
|
|
current_branch_only=False,
|
|
|
|
tags="",
|
|
|
|
git_event_log=None,
|
|
|
|
):
|
|
|
|
"""Sync a manifestProject, possibly for the first time.
|
|
|
|
|
|
|
|
Call Sync() with arguments from the most recent `repo init`. If this is
|
|
|
|
a new sub manifest, then inherit options from the parent's
|
|
|
|
manifestProject.
|
|
|
|
|
|
|
|
This is used by subcmds.Sync() to do an initial download of new sub
|
|
|
|
manifests.
|
2022-04-05 21:21:56 +00:00
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
Args:
|
|
|
|
submanifest: an XmlSubmanifest, the submanifest to re-sync.
|
|
|
|
verbose: a boolean, whether to show all output, rather than only
|
|
|
|
errors.
|
|
|
|
current_branch_only: a boolean, whether to only fetch the current
|
|
|
|
manifest branch from the server.
|
|
|
|
tags: a boolean, whether to fetch tags.
|
|
|
|
git_event_log: an EventLog, for git tracing.
|
|
|
|
"""
|
|
|
|
# TODO(lamontjones): when refactoring sync (and init?) consider how to
|
|
|
|
# better get the init options that we should use for new submanifests
|
|
|
|
# that are added when syncing an existing workspace.
|
|
|
|
git_event_log = git_event_log or EventLog()
|
2022-04-14 15:00:09 +00:00
|
|
|
spec = submanifest.ToSubmanifestSpec()
|
2023-03-11 06:46:20 +00:00
|
|
|
# Use the init options from the existing manifestProject, or the parent
|
|
|
|
# if it doesn't exist.
|
|
|
|
#
|
|
|
|
# Today, we only support changing manifest_groups on the sub-manifest,
|
|
|
|
# with no supported-for-the-user way to change the other arguments from
|
|
|
|
# those specified by the outermost manifest.
|
|
|
|
#
|
|
|
|
# TODO(lamontjones): determine which of these should come from the
|
|
|
|
# outermost manifest and which should come from the parent manifest.
|
|
|
|
mp = self if self.Exists else submanifest.parent.manifestProject
|
|
|
|
return self.Sync(
|
2022-04-06 17:10:21 +00:00
|
|
|
manifest_url=spec.manifestUrl,
|
|
|
|
manifest_branch=spec.revision,
|
2023-03-11 06:46:20 +00:00
|
|
|
standalone_manifest=mp.standalone_manifest_url,
|
|
|
|
groups=mp.manifest_groups,
|
|
|
|
platform=mp.manifest_platform,
|
|
|
|
mirror=mp.mirror,
|
|
|
|
dissociate=mp.dissociate,
|
|
|
|
reference=mp.reference,
|
|
|
|
worktree=mp.use_worktree,
|
|
|
|
submodules=mp.submodules,
|
|
|
|
archive=mp.archive,
|
|
|
|
partial_clone=mp.partial_clone,
|
|
|
|
clone_filter=mp.clone_filter,
|
|
|
|
partial_clone_exclude=mp.partial_clone_exclude,
|
|
|
|
clone_bundle=mp.clone_bundle,
|
|
|
|
git_lfs=mp.git_lfs,
|
|
|
|
use_superproject=mp.use_superproject,
|
2022-04-06 17:10:21 +00:00
|
|
|
verbose=verbose,
|
|
|
|
current_branch_only=current_branch_only,
|
|
|
|
tags=tags,
|
2023-03-11 06:46:20 +00:00
|
|
|
depth=mp.depth,
|
2022-04-06 17:10:21 +00:00
|
|
|
git_event_log=git_event_log,
|
|
|
|
manifest_name=spec.manifestName,
|
2023-03-11 06:46:20 +00:00
|
|
|
this_manifest_only=True,
|
2022-04-06 17:10:21 +00:00
|
|
|
outer_manifest=False,
|
2023-05-23 20:06:55 +00:00
|
|
|
clone_filter_for_depth=mp.clone_filter_for_depth,
|
2022-04-06 17:10:21 +00:00
|
|
|
)
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def Sync(
|
|
|
|
self,
|
|
|
|
_kwargs_only=(),
|
|
|
|
manifest_url="",
|
|
|
|
manifest_branch=None,
|
|
|
|
standalone_manifest=False,
|
|
|
|
groups="",
|
|
|
|
mirror=False,
|
|
|
|
reference="",
|
|
|
|
dissociate=False,
|
|
|
|
worktree=False,
|
|
|
|
submodules=False,
|
|
|
|
archive=False,
|
|
|
|
partial_clone=None,
|
|
|
|
depth=None,
|
|
|
|
clone_filter="blob:none",
|
|
|
|
partial_clone_exclude=None,
|
|
|
|
clone_bundle=None,
|
|
|
|
git_lfs=None,
|
|
|
|
use_superproject=None,
|
|
|
|
verbose=False,
|
|
|
|
current_branch_only=False,
|
|
|
|
git_event_log=None,
|
|
|
|
platform="",
|
|
|
|
manifest_name="default.xml",
|
|
|
|
tags="",
|
|
|
|
this_manifest_only=False,
|
|
|
|
outer_manifest=True,
|
2023-05-23 20:06:55 +00:00
|
|
|
clone_filter_for_depth=None,
|
2023-03-11 06:46:20 +00:00
|
|
|
):
|
|
|
|
"""Sync the manifest and all submanifests.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
manifest_url: a string, the URL of the manifest project.
|
|
|
|
manifest_branch: a string, the manifest branch to use.
|
|
|
|
standalone_manifest: a boolean, whether to store the manifest as a
|
|
|
|
static file.
|
|
|
|
groups: a string, restricts the checkout to projects with the
|
|
|
|
specified groups.
|
|
|
|
mirror: a boolean, whether to create a mirror of the remote
|
|
|
|
repository.
|
|
|
|
reference: a string, location of a repo instance to use as a
|
|
|
|
reference.
|
|
|
|
dissociate: a boolean, whether to dissociate from reference mirrors
|
|
|
|
after clone.
|
|
|
|
worktree: a boolean, whether to use git-worktree to manage projects.
|
|
|
|
submodules: a boolean, whether sync submodules associated with the
|
|
|
|
manifest project.
|
|
|
|
archive: a boolean, whether to checkout each project as an archive.
|
|
|
|
See git-archive.
|
|
|
|
partial_clone: a boolean, whether to perform a partial clone.
|
|
|
|
depth: an int, how deep of a shallow clone to create.
|
|
|
|
clone_filter: a string, filter to use with partial_clone.
|
|
|
|
partial_clone_exclude : a string, comma-delimeted list of project
|
|
|
|
names to exclude from partial clone.
|
|
|
|
clone_bundle: a boolean, whether to enable /clone.bundle on
|
|
|
|
HTTP/HTTPS.
|
|
|
|
git_lfs: a boolean, whether to enable git LFS support.
|
|
|
|
use_superproject: a boolean, whether to use the manifest
|
|
|
|
superproject to sync projects.
|
|
|
|
verbose: a boolean, whether to show all output, rather than only
|
|
|
|
errors.
|
|
|
|
current_branch_only: a boolean, whether to only fetch the current
|
|
|
|
manifest branch from the server.
|
|
|
|
platform: a string, restrict the checkout to projects with the
|
|
|
|
specified platform group.
|
|
|
|
git_event_log: an EventLog, for git tracing.
|
|
|
|
tags: a boolean, whether to fetch tags.
|
|
|
|
manifest_name: a string, the name of the manifest file to use.
|
|
|
|
this_manifest_only: a boolean, whether to only operate on the
|
|
|
|
current sub manifest.
|
|
|
|
outer_manifest: a boolean, whether to start at the outermost
|
|
|
|
manifest.
|
2023-05-23 20:06:55 +00:00
|
|
|
clone_filter_for_depth: a string, when specified replaces shallow
|
|
|
|
clones with partial.
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
Returns:
|
|
|
|
a boolean, whether the sync was successful.
|
|
|
|
"""
|
|
|
|
assert _kwargs_only == (), "Sync only accepts keyword arguments."
|
|
|
|
|
|
|
|
groups = groups or self.manifest.GetDefaultGroupsStr(
|
|
|
|
with_platform=False
|
|
|
|
)
|
|
|
|
platform = platform or "auto"
|
|
|
|
git_event_log = git_event_log or EventLog()
|
|
|
|
if outer_manifest and self.manifest.is_submanifest:
|
|
|
|
# In a multi-manifest checkout, use the outer manifest unless we are
|
|
|
|
# told not to.
|
|
|
|
return self.client.outer_manifest.manifestProject.Sync(
|
|
|
|
manifest_url=manifest_url,
|
|
|
|
manifest_branch=manifest_branch,
|
|
|
|
standalone_manifest=standalone_manifest,
|
|
|
|
groups=groups,
|
|
|
|
platform=platform,
|
|
|
|
mirror=mirror,
|
|
|
|
dissociate=dissociate,
|
|
|
|
reference=reference,
|
|
|
|
worktree=worktree,
|
|
|
|
submodules=submodules,
|
|
|
|
archive=archive,
|
|
|
|
partial_clone=partial_clone,
|
|
|
|
clone_filter=clone_filter,
|
|
|
|
partial_clone_exclude=partial_clone_exclude,
|
|
|
|
clone_bundle=clone_bundle,
|
|
|
|
git_lfs=git_lfs,
|
|
|
|
use_superproject=use_superproject,
|
|
|
|
verbose=verbose,
|
|
|
|
current_branch_only=current_branch_only,
|
|
|
|
tags=tags,
|
|
|
|
depth=depth,
|
|
|
|
git_event_log=git_event_log,
|
|
|
|
manifest_name=manifest_name,
|
|
|
|
this_manifest_only=this_manifest_only,
|
|
|
|
outer_manifest=False,
|
|
|
|
)
|
|
|
|
|
|
|
|
# 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 self.Exists:
|
|
|
|
was_standalone_manifest = self.config.GetString(
|
|
|
|
"manifest.standalone"
|
|
|
|
)
|
|
|
|
if was_standalone_manifest and not manifest_url:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
2023-03-11 06:46:20 +00:00
|
|
|
"fatal: repo was initialized with a standlone manifest, "
|
|
|
|
"cannot be re-initialized without --manifest-url/-u"
|
|
|
|
)
|
|
|
|
return False
|
|
|
|
|
|
|
|
if standalone_manifest or (
|
|
|
|
was_standalone_manifest and manifest_url
|
|
|
|
):
|
|
|
|
self.config.ClearCache()
|
|
|
|
if self.gitdir and os.path.exists(self.gitdir):
|
|
|
|
platform_utils.rmtree(self.gitdir)
|
|
|
|
if self.worktree and os.path.exists(self.worktree):
|
|
|
|
platform_utils.rmtree(self.worktree)
|
|
|
|
|
|
|
|
is_new = not self.Exists
|
|
|
|
if is_new:
|
|
|
|
if not manifest_url:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("fatal: manifest url is required.")
|
2023-03-11 06:46:20 +00:00
|
|
|
return False
|
|
|
|
|
|
|
|
if verbose:
|
|
|
|
print(
|
|
|
|
"Downloading manifest from %s"
|
|
|
|
% (GitConfig.ForUser().UrlInsteadOf(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 reference:
|
|
|
|
manifest_git_path = urllib.parse.urlparse(manifest_url).path[1:]
|
|
|
|
mirrored_manifest_git = os.path.join(
|
|
|
|
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(
|
|
|
|
reference, ".repo/manifests.git"
|
|
|
|
)
|
|
|
|
|
|
|
|
self._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.
|
|
|
|
if standalone_manifest:
|
|
|
|
self.config.SetString("manifest.standalone", manifest_url)
|
|
|
|
elif not manifest_url and not 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(
|
|
|
|
self.config.GetString("manifest.standalone")
|
|
|
|
)
|
|
|
|
if not standalone_manifest:
|
|
|
|
self.config.SetString("manifest.standalone", None)
|
|
|
|
|
|
|
|
self._ConfigureDepth(depth)
|
|
|
|
|
|
|
|
# Set the remote URL before the remote branch as we might need it below.
|
|
|
|
if manifest_url:
|
|
|
|
r = self.GetRemote()
|
|
|
|
r.url = manifest_url
|
|
|
|
r.ResetFetch()
|
|
|
|
r.Save()
|
|
|
|
|
|
|
|
if not standalone_manifest:
|
|
|
|
if manifest_branch:
|
|
|
|
if manifest_branch == "HEAD":
|
|
|
|
manifest_branch = self.ResolveRemoteHead()
|
|
|
|
if manifest_branch is None:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("fatal: unable to resolve HEAD")
|
2023-03-11 06:46:20 +00:00
|
|
|
return False
|
|
|
|
self.revisionExpr = manifest_branch
|
|
|
|
else:
|
|
|
|
if is_new:
|
|
|
|
default_branch = self.ResolveRemoteHead()
|
|
|
|
if default_branch is None:
|
|
|
|
# If the remote doesn't have HEAD configured, default to
|
|
|
|
# master.
|
|
|
|
default_branch = "refs/heads/master"
|
|
|
|
self.revisionExpr = default_branch
|
|
|
|
else:
|
|
|
|
self.PreSync()
|
|
|
|
|
|
|
|
groups = re.split(r"[,\s]+", groups or "")
|
|
|
|
all_platforms = ["linux", "darwin", "windows"]
|
|
|
|
platformize = lambda x: "platform-" + x
|
|
|
|
if platform == "auto":
|
|
|
|
if not mirror and not self.mirror:
|
|
|
|
groups.append(platformize(self._platform_name))
|
|
|
|
elif platform == "all":
|
|
|
|
groups.extend(map(platformize, all_platforms))
|
|
|
|
elif platform in all_platforms:
|
|
|
|
groups.append(platformize(platform))
|
|
|
|
elif platform != "none":
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("fatal: invalid platform flag", file=sys.stderr)
|
2023-03-11 06:46:20 +00:00
|
|
|
return False
|
|
|
|
self.config.SetString("manifest.platform", platform)
|
|
|
|
|
|
|
|
groups = [x for x in groups if x]
|
|
|
|
groupstr = ",".join(groups)
|
|
|
|
if (
|
|
|
|
platform == "auto"
|
|
|
|
and groupstr == self.manifest.GetDefaultGroupsStr()
|
|
|
|
):
|
|
|
|
groupstr = None
|
|
|
|
self.config.SetString("manifest.groups", groupstr)
|
|
|
|
|
|
|
|
if reference:
|
|
|
|
self.config.SetString("repo.reference", reference)
|
|
|
|
|
|
|
|
if dissociate:
|
|
|
|
self.config.SetBoolean("repo.dissociate", dissociate)
|
|
|
|
|
|
|
|
if worktree:
|
|
|
|
if mirror:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("fatal: --mirror and --worktree are incompatible")
|
2023-03-11 06:46:20 +00:00
|
|
|
return False
|
|
|
|
if submodules:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
|
|
|
"fatal: --submodules and --worktree are incompatible"
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
return False
|
|
|
|
self.config.SetBoolean("repo.worktree", worktree)
|
|
|
|
if is_new:
|
|
|
|
self.use_git_worktrees = True
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.warn("warning: --worktree is experimental!")
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
if archive:
|
|
|
|
if is_new:
|
|
|
|
self.config.SetBoolean("repo.archive", archive)
|
|
|
|
else:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
2023-03-11 06:46:20 +00:00
|
|
|
"fatal: --archive is only supported when initializing a "
|
2023-09-14 08:17:20 +00:00
|
|
|
"new workspace."
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
2023-03-11 06:46:20 +00:00
|
|
|
"Either delete the .repo folder in this workspace, or "
|
2023-09-14 08:17:20 +00:00
|
|
|
"initialize in another location."
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
return False
|
|
|
|
|
|
|
|
if mirror:
|
|
|
|
if is_new:
|
|
|
|
self.config.SetBoolean("repo.mirror", mirror)
|
|
|
|
else:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
2023-03-11 06:46:20 +00:00
|
|
|
"fatal: --mirror is only supported when initializing a new "
|
2023-09-14 08:17:20 +00:00
|
|
|
"workspace."
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
2023-03-11 06:46:20 +00:00
|
|
|
"Either delete the .repo folder in this workspace, or "
|
2023-09-14 08:17:20 +00:00
|
|
|
"initialize in another location."
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
return False
|
|
|
|
|
|
|
|
if partial_clone is not None:
|
|
|
|
if mirror:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
2023-03-11 06:46:20 +00:00
|
|
|
"fatal: --mirror and --partial-clone are mutually "
|
2023-09-14 08:17:20 +00:00
|
|
|
"exclusive"
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
return False
|
|
|
|
self.config.SetBoolean("repo.partialclone", partial_clone)
|
|
|
|
if clone_filter:
|
|
|
|
self.config.SetString("repo.clonefilter", clone_filter)
|
|
|
|
elif self.partial_clone:
|
|
|
|
clone_filter = self.clone_filter
|
|
|
|
else:
|
|
|
|
clone_filter = None
|
|
|
|
|
|
|
|
if partial_clone_exclude is not None:
|
|
|
|
self.config.SetString(
|
|
|
|
"repo.partialcloneexclude", partial_clone_exclude
|
|
|
|
)
|
|
|
|
|
|
|
|
if clone_bundle is None:
|
|
|
|
clone_bundle = False if partial_clone else True
|
|
|
|
else:
|
|
|
|
self.config.SetBoolean("repo.clonebundle", clone_bundle)
|
|
|
|
|
|
|
|
if submodules:
|
|
|
|
self.config.SetBoolean("repo.submodules", submodules)
|
|
|
|
|
|
|
|
if git_lfs is not None:
|
|
|
|
if git_lfs:
|
|
|
|
git_require((2, 17, 0), fail=True, msg="Git LFS support")
|
|
|
|
|
|
|
|
self.config.SetBoolean("repo.git-lfs", git_lfs)
|
|
|
|
if not is_new:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.warn(
|
2023-03-11 06:46:20 +00:00
|
|
|
"warning: Changing --git-lfs settings will only affect new "
|
|
|
|
"project checkouts.\n"
|
2023-09-14 08:17:20 +00:00
|
|
|
" Existing projects will require manual updates.\n"
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
|
2023-05-23 20:06:55 +00:00
|
|
|
if clone_filter_for_depth is not None:
|
|
|
|
self.ConfigureCloneFilterForDepth(clone_filter_for_depth)
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
if use_superproject is not None:
|
|
|
|
self.config.SetBoolean("repo.superproject", use_superproject)
|
|
|
|
|
|
|
|
if not standalone_manifest:
|
|
|
|
success = self.Sync_NetworkHalf(
|
|
|
|
is_new=is_new,
|
|
|
|
quiet=not verbose,
|
|
|
|
verbose=verbose,
|
|
|
|
clone_bundle=clone_bundle,
|
|
|
|
current_branch_only=current_branch_only,
|
|
|
|
tags=tags,
|
|
|
|
submodules=submodules,
|
|
|
|
clone_filter=clone_filter,
|
|
|
|
partial_clone_exclude=self.manifest.PartialCloneExclude,
|
2023-05-23 20:06:55 +00:00
|
|
|
clone_filter_for_depth=self.manifest.CloneFilterForDepth,
|
2023-03-11 06:46:20 +00:00
|
|
|
).success
|
|
|
|
if not success:
|
|
|
|
r = self.GetRemote()
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("fatal: cannot obtain manifest %s", r.url)
|
2023-03-11 06:46:20 +00:00
|
|
|
|
|
|
|
# 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(self.gitdir)
|
|
|
|
return False
|
|
|
|
|
|
|
|
if manifest_branch:
|
|
|
|
self.MetaBranchSwitch(submodules=submodules)
|
|
|
|
|
|
|
|
syncbuf = SyncBuffer(self.config)
|
|
|
|
self.Sync_LocalHalf(syncbuf, submodules=submodules)
|
|
|
|
syncbuf.Finish()
|
|
|
|
|
|
|
|
if is_new or self.CurrentBranch is None:
|
2023-08-08 21:12:53 +00:00
|
|
|
try:
|
|
|
|
self.StartBranch("default")
|
|
|
|
except GitError as e:
|
|
|
|
msg = str(e)
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error(
|
|
|
|
"fatal: cannot create default in manifest %s", msg
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
return False
|
|
|
|
|
|
|
|
if not manifest_name:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("fatal: manifest name (-m) is required.")
|
2023-03-11 06:46:20 +00:00
|
|
|
return False
|
|
|
|
|
|
|
|
elif is_new:
|
|
|
|
# This is a new standalone manifest.
|
|
|
|
manifest_name = "default.xml"
|
|
|
|
manifest_data = fetch.fetch_file(manifest_url, verbose=verbose)
|
|
|
|
dest = os.path.join(self.worktree, manifest_name)
|
|
|
|
os.makedirs(os.path.dirname(dest), exist_ok=True)
|
|
|
|
with open(dest, "wb") as f:
|
|
|
|
f.write(manifest_data)
|
|
|
|
|
|
|
|
try:
|
|
|
|
self.manifest.Link(manifest_name)
|
|
|
|
except ManifestParseError as e:
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.error("fatal: manifest '%s' not available", manifest_name)
|
|
|
|
logger.error("fatal: %s", e)
|
2023-03-11 06:46:20 +00:00
|
|
|
return False
|
|
|
|
|
|
|
|
if not this_manifest_only:
|
|
|
|
for submanifest in self.manifest.submanifests.values():
|
|
|
|
spec = submanifest.ToSubmanifestSpec()
|
|
|
|
submanifest.repo_client.manifestProject.Sync(
|
|
|
|
manifest_url=spec.manifestUrl,
|
|
|
|
manifest_branch=spec.revision,
|
|
|
|
standalone_manifest=standalone_manifest,
|
|
|
|
groups=self.manifest_groups,
|
|
|
|
platform=platform,
|
|
|
|
mirror=mirror,
|
|
|
|
dissociate=dissociate,
|
|
|
|
reference=reference,
|
|
|
|
worktree=worktree,
|
|
|
|
submodules=submodules,
|
|
|
|
archive=archive,
|
|
|
|
partial_clone=partial_clone,
|
|
|
|
clone_filter=clone_filter,
|
|
|
|
partial_clone_exclude=partial_clone_exclude,
|
|
|
|
clone_bundle=clone_bundle,
|
|
|
|
git_lfs=git_lfs,
|
|
|
|
use_superproject=use_superproject,
|
|
|
|
verbose=verbose,
|
|
|
|
current_branch_only=current_branch_only,
|
|
|
|
tags=tags,
|
|
|
|
depth=depth,
|
|
|
|
git_event_log=git_event_log,
|
|
|
|
manifest_name=spec.manifestName,
|
|
|
|
this_manifest_only=False,
|
|
|
|
outer_manifest=False,
|
|
|
|
)
|
|
|
|
|
|
|
|
# Lastly, if the manifest has a <superproject> then have the
|
|
|
|
# superproject sync it (if it will be used).
|
|
|
|
if git_superproject.UseSuperproject(use_superproject, self.manifest):
|
|
|
|
sync_result = self.manifest.superproject.Sync(git_event_log)
|
|
|
|
if not sync_result.success:
|
|
|
|
submanifest = ""
|
|
|
|
if self.manifest.path_prefix:
|
|
|
|
submanifest = f"for {self.manifest.path_prefix} "
|
2023-09-14 08:17:20 +00:00
|
|
|
logger.warn(
|
|
|
|
"warning: git update of superproject %s failed, "
|
2023-03-11 06:46:20 +00:00
|
|
|
"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",
|
2023-09-14 08:17:20 +00:00
|
|
|
submanifest,
|
2023-03-11 06:46:20 +00:00
|
|
|
)
|
|
|
|
if sync_result.fatal and use_superproject is not None:
|
|
|
|
return False
|
|
|
|
|
|
|
|
return True
|
|
|
|
|
2023-05-23 20:06:55 +00:00
|
|
|
def ConfigureCloneFilterForDepth(self, clone_filter_for_depth):
|
|
|
|
"""Configure clone filter to replace shallow clones.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
clone_filter_for_depth: a string or None, e.g. 'blob:none' will
|
|
|
|
disable shallow clones and replace with partial clone. None will
|
|
|
|
enable shallow clones.
|
|
|
|
"""
|
|
|
|
self.config.SetString(
|
|
|
|
"repo.clonefilterfordepth", clone_filter_for_depth
|
|
|
|
)
|
|
|
|
|
2023-03-11 06:46:20 +00:00
|
|
|
def _ConfigureDepth(self, depth):
|
|
|
|
"""Configure the depth we'll sync down.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
depth: an int, how deep of a partial clone to create.
|
|
|
|
"""
|
|
|
|
# Opt.depth will be non-None if user actually passed --depth to repo
|
|
|
|
# init.
|
|
|
|
if depth is not None:
|
|
|
|
if depth > 0:
|
|
|
|
# Positive values will set the depth.
|
|
|
|
depth = str(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.config.SetString("repo.depth", depth)
|