|
|
# commit.py - fonction to perform commit
|
|
|
#
|
|
|
# This software may be used and distributed according to the terms of the
|
|
|
# GNU General Public License version 2 or any later version.
|
|
|
|
|
|
from __future__ import absolute_import
|
|
|
|
|
|
import errno
|
|
|
import weakref
|
|
|
|
|
|
from .i18n import _
|
|
|
from .node import (
|
|
|
hex,
|
|
|
nullid,
|
|
|
nullrev,
|
|
|
)
|
|
|
|
|
|
from . import (
|
|
|
context,
|
|
|
mergestate,
|
|
|
metadata,
|
|
|
phases,
|
|
|
scmutil,
|
|
|
subrepoutil,
|
|
|
)
|
|
|
|
|
|
|
|
|
def commitctx(repo, ctx, error=False, origctx=None):
|
|
|
"""Add a new revision to the target repository.
|
|
|
Revision information is passed via the context argument.
|
|
|
|
|
|
ctx.files() should list all files involved in this commit, i.e.
|
|
|
modified/added/removed files. On merge, it may be wider than the
|
|
|
ctx.files() to be committed, since any file nodes derived directly
|
|
|
from p1 or p2 are excluded from the committed ctx.files().
|
|
|
|
|
|
origctx is for convert to work around the problem that bug
|
|
|
fixes to the files list in changesets change hashes. For
|
|
|
convert to be the identity, it can pass an origctx and this
|
|
|
function will use the same files list when it makes sense to
|
|
|
do so.
|
|
|
"""
|
|
|
repo = repo.unfiltered()
|
|
|
|
|
|
p1, p2 = ctx.p1(), ctx.p2()
|
|
|
user = ctx.user()
|
|
|
|
|
|
if repo.filecopiesmode == b'changeset-sidedata':
|
|
|
writechangesetcopy = True
|
|
|
writefilecopymeta = True
|
|
|
writecopiesto = None
|
|
|
else:
|
|
|
writecopiesto = repo.ui.config(b'experimental', b'copies.write-to')
|
|
|
writefilecopymeta = writecopiesto != b'changeset-only'
|
|
|
writechangesetcopy = writecopiesto in (
|
|
|
b'changeset-only',
|
|
|
b'compatibility',
|
|
|
)
|
|
|
p1copies, p2copies = None, None
|
|
|
if writechangesetcopy:
|
|
|
p1copies = ctx.p1copies()
|
|
|
p2copies = ctx.p2copies()
|
|
|
filesadded, filesremoved = None, None
|
|
|
with repo.lock(), repo.transaction(b"commit") as tr:
|
|
|
trp = weakref.proxy(tr)
|
|
|
|
|
|
if ctx.manifestnode():
|
|
|
# reuse an existing manifest revision
|
|
|
repo.ui.debug(b'reusing known manifest\n')
|
|
|
mn = ctx.manifestnode()
|
|
|
files = ctx.files()
|
|
|
if writechangesetcopy:
|
|
|
filesadded = ctx.filesadded()
|
|
|
filesremoved = ctx.filesremoved()
|
|
|
elif not ctx.files():
|
|
|
repo.ui.debug(b'reusing manifest from p1 (no file change)\n')
|
|
|
mn = p1.manifestnode()
|
|
|
files = []
|
|
|
else:
|
|
|
m1ctx = p1.manifestctx()
|
|
|
m2ctx = p2.manifestctx()
|
|
|
mctx = m1ctx.copy()
|
|
|
|
|
|
m = mctx.read()
|
|
|
m1 = m1ctx.read()
|
|
|
m2 = m2ctx.read()
|
|
|
|
|
|
# check in files
|
|
|
added = []
|
|
|
filesadded = []
|
|
|
removed = list(ctx.removed())
|
|
|
touched = []
|
|
|
linkrev = len(repo)
|
|
|
repo.ui.note(_(b"committing files:\n"))
|
|
|
uipathfn = scmutil.getuipathfn(repo)
|
|
|
for f in sorted(ctx.modified() + ctx.added()):
|
|
|
repo.ui.note(uipathfn(f) + b"\n")
|
|
|
try:
|
|
|
fctx = ctx[f]
|
|
|
if fctx is None:
|
|
|
removed.append(f)
|
|
|
else:
|
|
|
added.append(f)
|
|
|
m[f], is_touched = _filecommit(
|
|
|
repo, fctx, m1, m2, linkrev, trp, writefilecopymeta,
|
|
|
)
|
|
|
if is_touched:
|
|
|
touched.append(f)
|
|
|
if writechangesetcopy and is_touched == 'added':
|
|
|
filesadded.append(f)
|
|
|
m.setflag(f, fctx.flags())
|
|
|
except OSError:
|
|
|
repo.ui.warn(_(b"trouble committing %s!\n") % uipathfn(f))
|
|
|
raise
|
|
|
except IOError as inst:
|
|
|
errcode = getattr(inst, 'errno', errno.ENOENT)
|
|
|
if error or errcode and errcode != errno.ENOENT:
|
|
|
repo.ui.warn(
|
|
|
_(b"trouble committing %s!\n") % uipathfn(f)
|
|
|
)
|
|
|
raise
|
|
|
|
|
|
# update manifest
|
|
|
removed = [f for f in removed if f in m1 or f in m2]
|
|
|
drop = sorted([f for f in removed if f in m])
|
|
|
for f in drop:
|
|
|
del m[f]
|
|
|
if p2.rev() != nullrev:
|
|
|
rf = metadata.get_removal_filter(ctx, (p1, p2, m1, m2))
|
|
|
removed = [f for f in removed if not rf(f)]
|
|
|
|
|
|
touched.extend(removed)
|
|
|
|
|
|
if writechangesetcopy:
|
|
|
filesremoved = removed
|
|
|
|
|
|
files = touched
|
|
|
md = None
|
|
|
if not files:
|
|
|
# if no "files" actually changed in terms of the changelog,
|
|
|
# try hard to detect unmodified manifest entry so that the
|
|
|
# exact same commit can be reproduced later on convert.
|
|
|
md = m1.diff(m, scmutil.matchfiles(repo, ctx.files()))
|
|
|
if not files and md:
|
|
|
repo.ui.debug(
|
|
|
b'not reusing manifest (no file change in '
|
|
|
b'changelog, but manifest differs)\n'
|
|
|
)
|
|
|
if files or md:
|
|
|
repo.ui.note(_(b"committing manifest\n"))
|
|
|
# we're using narrowmatch here since it's already applied at
|
|
|
# other stages (such as dirstate.walk), so we're already
|
|
|
# ignoring things outside of narrowspec in most cases. The
|
|
|
# one case where we might have files outside the narrowspec
|
|
|
# at this point is merges, and we already error out in the
|
|
|
# case where the merge has files outside of the narrowspec,
|
|
|
# so this is safe.
|
|
|
mn = mctx.write(
|
|
|
trp,
|
|
|
linkrev,
|
|
|
p1.manifestnode(),
|
|
|
p2.manifestnode(),
|
|
|
added,
|
|
|
drop,
|
|
|
match=repo.narrowmatch(),
|
|
|
)
|
|
|
else:
|
|
|
repo.ui.debug(
|
|
|
b'reusing manifest from p1 (listed files '
|
|
|
b'actually unchanged)\n'
|
|
|
)
|
|
|
mn = p1.manifestnode()
|
|
|
|
|
|
if writecopiesto == b'changeset-only':
|
|
|
# If writing only to changeset extras, use None to indicate that
|
|
|
# no entry should be written. If writing to both, write an empty
|
|
|
# entry to prevent the reader from falling back to reading
|
|
|
# filelogs.
|
|
|
p1copies = p1copies or None
|
|
|
p2copies = p2copies or None
|
|
|
filesadded = filesadded or None
|
|
|
filesremoved = filesremoved or None
|
|
|
|
|
|
if origctx and origctx.manifestnode() == mn:
|
|
|
files = origctx.files()
|
|
|
|
|
|
# update changelog
|
|
|
repo.ui.note(_(b"committing changelog\n"))
|
|
|
repo.changelog.delayupdate(tr)
|
|
|
n = repo.changelog.add(
|
|
|
mn,
|
|
|
files,
|
|
|
ctx.description(),
|
|
|
trp,
|
|
|
p1.node(),
|
|
|
p2.node(),
|
|
|
user,
|
|
|
ctx.date(),
|
|
|
ctx.extra().copy(),
|
|
|
p1copies,
|
|
|
p2copies,
|
|
|
filesadded,
|
|
|
filesremoved,
|
|
|
)
|
|
|
xp1, xp2 = p1.hex(), p2 and p2.hex() or b''
|
|
|
repo.hook(
|
|
|
b'pretxncommit', throw=True, node=hex(n), parent1=xp1, parent2=xp2,
|
|
|
)
|
|
|
# set the new commit is proper phase
|
|
|
targetphase = subrepoutil.newcommitphase(repo.ui, ctx)
|
|
|
if targetphase:
|
|
|
# retract boundary do not alter parent changeset.
|
|
|
# if a parent have higher the resulting phase will
|
|
|
# be compliant anyway
|
|
|
#
|
|
|
# if minimal phase was 0 we don't need to retract anything
|
|
|
phases.registernew(repo, tr, targetphase, [n])
|
|
|
return n
|
|
|
|
|
|
|
|
|
def _filecommit(
|
|
|
repo, fctx, manifest1, manifest2, linkrev, tr, includecopymeta,
|
|
|
):
|
|
|
"""
|
|
|
commit an individual file as part of a larger transaction
|
|
|
|
|
|
input:
|
|
|
|
|
|
fctx: a file context with the content we are trying to commit
|
|
|
manifest1: manifest of changeset first parent
|
|
|
manifest2: manifest of changeset second parent
|
|
|
linkrev: revision number of the changeset being created
|
|
|
tr: current transation
|
|
|
individual: boolean, set to False to skip storing the copy data
|
|
|
(only used by the Google specific feature of using
|
|
|
changeset extra as copy source of truth).
|
|
|
|
|
|
output: (filenode, touched)
|
|
|
|
|
|
filenode: the filenode that should be used by this changeset
|
|
|
touched: one of: None, 'added' or 'modified'
|
|
|
"""
|
|
|
|
|
|
fname = fctx.path()
|
|
|
fparent1 = manifest1.get(fname, nullid)
|
|
|
fparent2 = manifest2.get(fname, nullid)
|
|
|
touched = None
|
|
|
if fparent1 == fparent2 == nullid:
|
|
|
touched = 'added'
|
|
|
|
|
|
if isinstance(fctx, context.filectx):
|
|
|
# This block fast path most comparisons which are usually done. It
|
|
|
# assumes that bare filectx is used and no merge happened, hence no
|
|
|
# need to create a new file revision in this case.
|
|
|
node = fctx.filenode()
|
|
|
if node in [fparent1, fparent2]:
|
|
|
repo.ui.debug(b'reusing %s filelog entry\n' % fname)
|
|
|
if (
|
|
|
fparent1 != nullid and manifest1.flags(fname) != fctx.flags()
|
|
|
) or (
|
|
|
fparent2 != nullid and manifest2.flags(fname) != fctx.flags()
|
|
|
):
|
|
|
touched = 'modified'
|
|
|
return node, touched
|
|
|
|
|
|
flog = repo.file(fname)
|
|
|
meta = {}
|
|
|
cfname = fctx.copysource()
|
|
|
fnode = None
|
|
|
|
|
|
if cfname and cfname != fname:
|
|
|
# Mark the new revision of this file as a copy of another
|
|
|
# file. This copy data will effectively act as a parent
|
|
|
# of this new revision. If this is a merge, the first
|
|
|
# parent will be the nullid (meaning "look up the copy data")
|
|
|
# and the second one will be the other parent. For example:
|
|
|
#
|
|
|
# 0 --- 1 --- 3 rev1 changes file foo
|
|
|
# \ / rev2 renames foo to bar and changes it
|
|
|
# \- 2 -/ rev3 should have bar with all changes and
|
|
|
# should record that bar descends from
|
|
|
# bar in rev2 and foo in rev1
|
|
|
#
|
|
|
# this allows this merge to succeed:
|
|
|
#
|
|
|
# 0 --- 1 --- 3 rev4 reverts the content change from rev2
|
|
|
# \ / merging rev3 and rev4 should use bar@rev2
|
|
|
# \- 2 --- 4 as the merge base
|
|
|
#
|
|
|
|
|
|
cnode = manifest1.get(cfname)
|
|
|
newfparent = fparent2
|
|
|
|
|
|
if manifest2: # branch merge
|
|
|
if fparent2 == nullid or cnode is None: # copied on remote side
|
|
|
if cfname in manifest2:
|
|
|
cnode = manifest2[cfname]
|
|
|
newfparent = fparent1
|
|
|
|
|
|
# Here, we used to search backwards through history to try to find
|
|
|
# where the file copy came from if the source of a copy was not in
|
|
|
# the parent directory. However, this doesn't actually make sense to
|
|
|
# do (what does a copy from something not in your working copy even
|
|
|
# mean?) and it causes bugs (eg, issue4476). Instead, we will warn
|
|
|
# the user that copy information was dropped, so if they didn't
|
|
|
# expect this outcome it can be fixed, but this is the correct
|
|
|
# behavior in this circumstance.
|
|
|
|
|
|
if cnode:
|
|
|
repo.ui.debug(b" %s: copy %s:%s\n" % (fname, cfname, hex(cnode)))
|
|
|
if includecopymeta:
|
|
|
meta[b"copy"] = cfname
|
|
|
meta[b"copyrev"] = hex(cnode)
|
|
|
fparent1, fparent2 = nullid, newfparent
|
|
|
else:
|
|
|
repo.ui.warn(
|
|
|
_(
|
|
|
b"warning: can't find ancestor for '%s' "
|
|
|
b"copied from '%s'!\n"
|
|
|
)
|
|
|
% (fname, cfname)
|
|
|
)
|
|
|
|
|
|
elif fparent1 == nullid:
|
|
|
fparent1, fparent2 = fparent2, nullid
|
|
|
elif fparent2 != nullid:
|
|
|
# is one parent an ancestor of the other?
|
|
|
fparentancestors = flog.commonancestorsheads(fparent1, fparent2)
|
|
|
if fparent1 in fparentancestors:
|
|
|
fparent1, fparent2 = fparent2, nullid
|
|
|
elif fparent2 in fparentancestors:
|
|
|
fparent2 = nullid
|
|
|
elif not fparentancestors:
|
|
|
# TODO: this whole if-else might be simplified much more
|
|
|
ms = mergestate.mergestate.read(repo)
|
|
|
if (
|
|
|
fname in ms
|
|
|
and ms[fname] == mergestate.MERGE_RECORD_MERGED_OTHER
|
|
|
):
|
|
|
fparent1, fparent2 = fparent2, nullid
|
|
|
|
|
|
# is the file changed?
|
|
|
text = fctx.data()
|
|
|
if fparent2 != nullid or meta or flog.cmp(fparent1, text):
|
|
|
if touched is None: # do not overwrite added
|
|
|
touched = 'modified'
|
|
|
fnode = flog.add(text, meta, tr, linkrev, fparent1, fparent2)
|
|
|
# are just the flags changed during merge?
|
|
|
elif fname in manifest1 and manifest1.flags(fname) != fctx.flags():
|
|
|
touched = 'modified'
|
|
|
fnode = fparent1
|
|
|
else:
|
|
|
fnode = fparent1
|
|
|
return fnode, touched
|
|
|
|
