| indygreg | |
| durin42 | |
| martinvonz |
| hg-reviewers |
The introduction of 256bit hashes require changes to nullid and other
constant magic values. Start pushing them down from repository and
revlog where sensible.
| No Linters Available |
| No Unit Test Coverage |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| 5886e284ce08 | 5fa019ceb499 | Joerg Sonnenberger | Mar 28 2021, 7:52 PM |
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| short, | short, | ||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| cmdutil, | cmdutil, | ||||
| commands, | commands, | ||||
| context, | context, | ||||
| crecord, | crecord, | ||||
| error, | error, | ||||
| def __init__(self, repo): | def __init__(self, repo): | ||||
| self._repo = repo | self._repo = repo | ||||
| def data(self): | def data(self): | ||||
| return b'' | return b'' | ||||
| def node(self): | def node(self): | ||||
| return nullid | return self._repo.nullid | ||||
| def uniq(lst): | def uniq(lst): | ||||
| """list -> list. remove duplicated items without changing the order""" | """list -> list. remove duplicated items without changing the order""" | ||||
| seen = set() | seen = set() | ||||
| result = [] | result = [] | ||||
| for x in lst: | for x in lst: | ||||
| if x not in seen: | if x not in seen: | ||||
| return True | return True | ||||
| def _commitsingle(self, memworkingcopy, ctx, p1=None): | def _commitsingle(self, memworkingcopy, ctx, p1=None): | ||||
| """(ctx, {path: content}, node) -> node. make a single commit | """(ctx, {path: content}, node) -> node. make a single commit | ||||
| the commit is a clone from ctx, with a (optionally) different p1, and | the commit is a clone from ctx, with a (optionally) different p1, and | ||||
| different file contents replaced by memworkingcopy. | different file contents replaced by memworkingcopy. | ||||
| """ | """ | ||||
| parents = p1 and (p1, nullid) | parents = p1 and (p1, self.repo.nullid) | ||||
| extra = ctx.extra() | extra = ctx.extra() | ||||
| if self._useobsolete and self.ui.configbool(b'absorb', b'add-noise'): | if self._useobsolete and self.ui.configbool(b'absorb', b'add-noise'): | ||||
| extra[b'absorb_source'] = ctx.hex() | extra[b'absorb_source'] = ctx.hex() | ||||
| desc = rewriteutil.update_hash_refs( | desc = rewriteutil.update_hash_refs( | ||||
| ctx.repo(), | ctx.repo(), | ||||
| ctx.description(), | ctx.description(), | ||||
| { | { | ||||
| # git.py - git support for the convert extension | # git.py - git support for the convert extension | ||||
| # | # | ||||
| # Copyright 2005-2009 Olivia Mackall <olivia@selenic.com> and others | # Copyright 2005-2009 Olivia Mackall <olivia@selenic.com> and others | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import os | import os | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import nullhex | from mercurial.node import sha1nodeconstants | ||||
| from mercurial import ( | from mercurial import ( | ||||
| config, | config, | ||||
| error, | error, | ||||
| pycompat, | pycompat, | ||||
| ) | ) | ||||
| from . import common | from . import common | ||||
| for rev in self.revs: | for rev in self.revs: | ||||
| rawhead, ret = self.gitrun(b'rev-parse', b'--verify', rev) | rawhead, ret = self.gitrun(b'rev-parse', b'--verify', rev) | ||||
| heads.append(rawhead[:-1]) | heads.append(rawhead[:-1]) | ||||
| if ret: | if ret: | ||||
| raise error.Abort(_(b'cannot retrieve git head "%s"') % rev) | raise error.Abort(_(b'cannot retrieve git head "%s"') % rev) | ||||
| return heads | return heads | ||||
| def catfile(self, rev, ftype): | def catfile(self, rev, ftype): | ||||
| if rev == nullhex: | if rev == sha1nodeconstants.nullhex: | ||||
| raise IOError | raise IOError | ||||
| self.catfilepipe[0].write(rev + b'\n') | self.catfilepipe[0].write(rev + b'\n') | ||||
| self.catfilepipe[0].flush() | self.catfilepipe[0].flush() | ||||
| info = self.catfilepipe[1].readline().split() | info = self.catfilepipe[1].readline().split() | ||||
| if info[1] != ftype: | if info[1] != ftype: | ||||
| raise error.Abort( | raise error.Abort( | ||||
| _(b'cannot read %r object at %s') | _(b'cannot read %r object at %s') | ||||
| % (pycompat.bytestr(ftype), rev) | % (pycompat.bytestr(ftype), rev) | ||||
| ) | ) | ||||
| size = int(info[2]) | size = int(info[2]) | ||||
| data = self.catfilepipe[1].read(size) | data = self.catfilepipe[1].read(size) | ||||
| if len(data) < size: | if len(data) < size: | ||||
| raise error.Abort( | raise error.Abort( | ||||
| _(b'cannot read %r object at %s: unexpected size') | _(b'cannot read %r object at %s: unexpected size') | ||||
| % (ftype, rev) | % (ftype, rev) | ||||
| ) | ) | ||||
| # read the trailing newline | # read the trailing newline | ||||
| self.catfilepipe[1].read(1) | self.catfilepipe[1].read(1) | ||||
| return data | return data | ||||
| def getfile(self, name, rev): | def getfile(self, name, rev): | ||||
| if rev == nullhex: | if rev == sha1nodeconstants.nullhex: | ||||
| return None, None | return None, None | ||||
| if name == b'.hgsub': | if name == b'.hgsub': | ||||
| data = b'\n'.join([m.hgsub() for m in self.submoditer()]) | data = b'\n'.join([m.hgsub() for m in self.submoditer()]) | ||||
| mode = b'' | mode = b'' | ||||
| elif name == b'.hgsubstate': | elif name == b'.hgsubstate': | ||||
| data = b'\n'.join([m.hgsubstate() for m in self.submoditer()]) | data = b'\n'.join([m.hgsubstate() for m in self.submoditer()]) | ||||
| mode = b'' | mode = b'' | ||||
| else: | else: | ||||
| data = self.catfile(rev, b"blob") | data = self.catfile(rev, b"blob") | ||||
| mode = self.modecache[(name, rev)] | mode = self.modecache[(name, rev)] | ||||
| return data, mode | return data, mode | ||||
| def submoditer(self): | def submoditer(self): | ||||
| null = nullhex | null = sha1nodeconstants.nullhex | ||||
| for m in sorted(self.submodules, key=lambda p: p.path): | for m in sorted(self.submodules, key=lambda p: p.path): | ||||
| if m.node != null: | if m.node != null: | ||||
| yield m | yield m | ||||
| def parsegitmodules(self, content): | def parsegitmodules(self, content): | ||||
| """Parse the formatted .gitmodules file, example file format: | """Parse the formatted .gitmodules file, example file format: | ||||
| [submodule "sub"]\n | [submodule "sub"]\n | ||||
| \tpath = sub\n | \tpath = sub\n | ||||
| if f == b'.gitmodules': | if f == b'.gitmodules': | ||||
| if skipsubmodules: | if skipsubmodules: | ||||
| return | return | ||||
| subexists[0] = True | subexists[0] = True | ||||
| if entry[4] == b'D' or renamesource: | if entry[4] == b'D' or renamesource: | ||||
| subdeleted[0] = True | subdeleted[0] = True | ||||
| changes.append((b'.hgsub', nullhex)) | changes.append((b'.hgsub', sha1nodeconstants.nullhex)) | ||||
| else: | else: | ||||
| changes.append((b'.hgsub', b'')) | changes.append((b'.hgsub', b'')) | ||||
| elif entry[1] == b'160000' or entry[0] == b':160000': | elif entry[1] == b'160000' or entry[0] == b':160000': | ||||
| if not skipsubmodules: | if not skipsubmodules: | ||||
| subexists[0] = True | subexists[0] = True | ||||
| else: | else: | ||||
| if renamesource: | if renamesource: | ||||
| h = nullhex | h = sha1nodeconstants.nullhex | ||||
| self.modecache[(f, h)] = (p and b"x") or (s and b"l") or b"" | self.modecache[(f, h)] = (p and b"x") or (s and b"l") or b"" | ||||
| changes.append((f, h)) | changes.append((f, h)) | ||||
| while i < lcount: | while i < lcount: | ||||
| l = difftree[i] | l = difftree[i] | ||||
| i += 1 | i += 1 | ||||
| if not entry: | if not entry: | ||||
| if not l.startswith(b':'): | if not l.startswith(b':'): | ||||
| # .gitmodules isn't imported at all, so it being copied to | # .gitmodules isn't imported at all, so it being copied to | ||||
| # and fro doesn't really make sense | # and fro doesn't really make sense | ||||
| if f != b'.gitmodules' and fdest != b'.gitmodules': | if f != b'.gitmodules' and fdest != b'.gitmodules': | ||||
| copies[fdest] = f | copies[fdest] = f | ||||
| entry = None | entry = None | ||||
| if subexists[0]: | if subexists[0]: | ||||
| if subdeleted[0]: | if subdeleted[0]: | ||||
| changes.append((b'.hgsubstate', nullhex)) | changes.append((b'.hgsubstate', sha1nodeconstants.nullhex)) | ||||
| else: | else: | ||||
| self.retrievegitmodules(version) | self.retrievegitmodules(version) | ||||
| changes.append((b'.hgsubstate', b'')) | changes.append((b'.hgsubstate', b'')) | ||||
| return (changes, copies, set()) | return (changes, copies, set()) | ||||
| def getcommit(self, version): | def getcommit(self, version): | ||||
| c = self.catfile(version, b"commit") # read the commit hash | c = self.catfile(version, b"commit") # read the commit hash | ||||
| end = c.find(b"\n\n") | end = c.find(b"\n\n") | ||||
| import re | import re | ||||
| import time | import time | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.pycompat import open | from mercurial.pycompat import open | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullhex, | sha1nodeconstants, | ||||
| nullid, | |||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| bookmarks, | bookmarks, | ||||
| context, | context, | ||||
| error, | error, | ||||
| exchange, | exchange, | ||||
| hg, | hg, | ||||
| lock as lockmod, | lock as lockmod, | ||||
| for line in data.splitlines(): | for line in data.splitlines(): | ||||
| s = line.split(b' ', 1) | s = line.split(b' ', 1) | ||||
| if len(s) != 2: | if len(s) != 2: | ||||
| self.ui.warn(_(b'invalid tag entry: "%s"\n') % line) | self.ui.warn(_(b'invalid tag entry: "%s"\n') % line) | ||||
| fp.write(b'%s\n' % line) # Bogus, but keep for hash stability | fp.write(b'%s\n' % line) # Bogus, but keep for hash stability | ||||
| continue | continue | ||||
| revid = revmap.get(source.lookuprev(s[0])) | revid = revmap.get(source.lookuprev(s[0])) | ||||
| if not revid: | if not revid: | ||||
| if s[0] == nullhex: | if s[0] == sha1nodeconstants.nullhex: | ||||
| revid = s[0] | revid = s[0] | ||||
| else: | else: | ||||
| # missing, but keep for hash stability | # missing, but keep for hash stability | ||||
| self.ui.warn(_(b'missing tag entry: "%s"\n') % line) | self.ui.warn(_(b'missing tag entry: "%s"\n') % line) | ||||
| fp.write(b'%s\n' % line) | fp.write(b'%s\n' % line) | ||||
| continue | continue | ||||
| fp.write(b'%s %s\n' % (revid, s[1])) | fp.write(b'%s %s\n' % (revid, s[1])) | ||||
| return fp.getvalue() | return fp.getvalue() | ||||
| def _rewritesubstate(self, source, data): | def _rewritesubstate(self, source, data): | ||||
| fp = stringio() | fp = stringio() | ||||
| for line in data.splitlines(): | for line in data.splitlines(): | ||||
| s = line.split(b' ', 1) | s = line.split(b' ', 1) | ||||
| if len(s) != 2: | if len(s) != 2: | ||||
| continue | continue | ||||
| revid = s[0] | revid = s[0] | ||||
| subpath = s[1] | subpath = s[1] | ||||
| if revid != nullhex: | if revid != sha1nodeconstants.nullhex: | ||||
| revmap = self.subrevmaps.get(subpath) | revmap = self.subrevmaps.get(subpath) | ||||
| if revmap is None: | if revmap is None: | ||||
| revmap = mapfile( | revmap = mapfile( | ||||
| self.ui, self.repo.wjoin(subpath, b'.hg/shamap') | self.ui, self.repo.wjoin(subpath, b'.hg/shamap') | ||||
| ) | ) | ||||
| self.subrevmaps[subpath] = revmap | self.subrevmaps[subpath] = revmap | ||||
| # It is reasonable that one or more of the subrepos don't | # It is reasonable that one or more of the subrepos don't | ||||
| pl.append(p) | pl.append(p) | ||||
| parents = pl | parents = pl | ||||
| nparents = len(parents) | nparents = len(parents) | ||||
| if self.filemapmode and nparents == 1: | if self.filemapmode and nparents == 1: | ||||
| m1node = self.repo.changelog.read(bin(parents[0]))[0] | m1node = self.repo.changelog.read(bin(parents[0]))[0] | ||||
| parent = parents[0] | parent = parents[0] | ||||
| if len(parents) < 2: | if len(parents) < 2: | ||||
| parents.append(nullid) | parents.append(self.repo.nullid) | ||||
| if len(parents) < 2: | if len(parents) < 2: | ||||
| parents.append(nullid) | parents.append(self.repo.nullid) | ||||
| p2 = parents.pop(0) | p2 = parents.pop(0) | ||||
| text = commit.desc | text = commit.desc | ||||
| sha1s = re.findall(sha1re, text) | sha1s = re.findall(sha1re, text) | ||||
| for sha1 in sha1s: | for sha1 in sha1s: | ||||
| oldrev = source.lookuprev(sha1) | oldrev = source.lookuprev(sha1) | ||||
| newrev = revmap.get(oldrev) | newrev = revmap.get(oldrev) | ||||
| if commit.rev and commit.saverev: | if commit.rev and commit.saverev: | ||||
| extra[b'convert_revision'] = commit.rev | extra[b'convert_revision'] = commit.rev | ||||
| while parents: | while parents: | ||||
| p1 = p2 | p1 = p2 | ||||
| p2 = parents.pop(0) | p2 = parents.pop(0) | ||||
| p1ctx = self.repo[p1] | p1ctx = self.repo[p1] | ||||
| p2ctx = None | p2ctx = None | ||||
| if p2 != nullid: | if p2 != self.repo.nullid: | ||||
| p2ctx = self.repo[p2] | p2ctx = self.repo[p2] | ||||
| fileset = set(files) | fileset = set(files) | ||||
| if full: | if full: | ||||
| fileset.update(self.repo[p1]) | fileset.update(self.repo[p1]) | ||||
| fileset.update(self.repo[p2]) | fileset.update(self.repo[p2]) | ||||
| if p2ctx: | if p2ctx: | ||||
| p2files = set(cleanp2) | p2files = set(cleanp2) | ||||
| if not closed and not man.cmp(m1node, man.revision(mnode)): | if not closed and not man.cmp(m1node, man.revision(mnode)): | ||||
| self.ui.status(_(b"filtering out empty revision\n")) | self.ui.status(_(b"filtering out empty revision\n")) | ||||
| self.repo.rollback(force=True) | self.repo.rollback(force=True) | ||||
| return parent | return parent | ||||
| return p2 | return p2 | ||||
| def puttags(self, tags): | def puttags(self, tags): | ||||
| tagparent = self.repo.branchtip(self.tagsbranch, ignoremissing=True) | tagparent = self.repo.branchtip(self.tagsbranch, ignoremissing=True) | ||||
| tagparent = tagparent or nullid | tagparent = tagparent or self.repo.nullid | ||||
| oldlines = set() | oldlines = set() | ||||
| for branch, heads in pycompat.iteritems(self.repo.branchmap()): | for branch, heads in pycompat.iteritems(self.repo.branchmap()): | ||||
| for h in heads: | for h in heads: | ||||
| if b'.hgtags' in self.repo[h]: | if b'.hgtags' in self.repo[h]: | ||||
| oldlines.update( | oldlines.update( | ||||
| set(self.repo[h][b'.hgtags'].data().splitlines(True)) | set(self.repo[h][b'.hgtags'].data().splitlines(True)) | ||||
| ) | ) | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import contextlib | import contextlib | ||||
| import errno | import errno | ||||
| import os | import os | ||||
| from mercurial.node import nullid | from mercurial.node import sha1nodeconstants | ||||
| from mercurial import ( | from mercurial import ( | ||||
| error, | error, | ||||
| extensions, | extensions, | ||||
| match as matchmod, | match as matchmod, | ||||
| pycompat, | pycompat, | ||||
| scmutil, | scmutil, | ||||
| util, | util, | ||||
| ) | ) | ||||
| self._plchangecallbacks = {} | self._plchangecallbacks = {} | ||||
| def p1(self): | def p1(self): | ||||
| try: | try: | ||||
| return self.git.head.peel().id.raw | return self.git.head.peel().id.raw | ||||
| except pygit2.GitError: | except pygit2.GitError: | ||||
| # Typically happens when peeling HEAD fails, as in an | # Typically happens when peeling HEAD fails, as in an | ||||
| # empty repository. | # empty repository. | ||||
| return nullid | return sha1nodeconstants.nullid | ||||
| def p2(self): | def p2(self): | ||||
| # TODO: MERGE_HEAD? something like that, right? | # TODO: MERGE_HEAD? something like that, right? | ||||
| return nullid | return sha1nodeconstants.nullid | ||||
| def setparents(self, p1, p2=nullid): | def setparents(self, p1, p2=None): | ||||
| assert p2 == nullid, b'TODO merging support' | if p2 is None: | ||||
| p2 = sha1nodeconstants.nullid | |||||
| assert p2 == sha1nodeconstants.nullid, b'TODO merging support' | |||||
| self.git.head.set_target(gitutil.togitnode(p1)) | self.git.head.set_target(gitutil.togitnode(p1)) | ||||
| @util.propertycache | @util.propertycache | ||||
| def identity(self): | def identity(self): | ||||
| return util.filestat.frompath( | return util.filestat.frompath( | ||||
| os.path.join(self._root, b'.git', b'index') | os.path.join(self._root, b'.git', b'index') | ||||
| ) | ) | ||||
| def branch(self): | def branch(self): | ||||
| return b'default' | return b'default' | ||||
| def parents(self): | def parents(self): | ||||
| # TODO how on earth do we find p2 if a merge is in flight? | # TODO how on earth do we find p2 if a merge is in flight? | ||||
| return self.p1(), nullid | return self.p1(), sha1nodeconstants.nullid | ||||
| def __iter__(self): | def __iter__(self): | ||||
| return (pycompat.fsencode(f.path) for f in self.git.index) | return (pycompat.fsencode(f.path) for f in self.git.index) | ||||
| def items(self): | def items(self): | ||||
| for ie in self.git.index: | for ie in self.git.index: | ||||
| yield ie.path, None # value should be a dirstatetuple | yield ie.path, None # value should be a dirstatetuple | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullhex, | |||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| sha1nodeconstants, | sha1nodeconstants, | ||||
| wdirhex, | |||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| ancestor, | ancestor, | ||||
| changelog as hgchangelog, | changelog as hgchangelog, | ||||
| dagop, | dagop, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| manifest, | manifest, | ||||
| self._db = db | self._db = db | ||||
| def __len__(self): | def __len__(self): | ||||
| return int( | return int( | ||||
| self._db.execute('SELECT COUNT(*) FROM changelog').fetchone()[0] | self._db.execute('SELECT COUNT(*) FROM changelog').fetchone()[0] | ||||
| ) | ) | ||||
| def rev(self, n): | def rev(self, n): | ||||
| if n == nullid: | if n == sha1nodeconstants.nullid: | ||||
| return -1 | return -1 | ||||
| t = self._db.execute( | t = self._db.execute( | ||||
| 'SELECT rev FROM changelog WHERE node = ?', (gitutil.togitnode(n),) | 'SELECT rev FROM changelog WHERE node = ?', (gitutil.togitnode(n),) | ||||
| ).fetchone() | ).fetchone() | ||||
| if t is None: | if t is None: | ||||
| raise error.LookupError(n, b'00changelog.i', _(b'no node %d')) | raise error.LookupError(n, b'00changelog.i', _(b'no node %d')) | ||||
| return t[0] | return t[0] | ||||
| def node(self, r): | def node(self, r): | ||||
| if r == nullrev: | if r == nullrev: | ||||
| return nullid | return sha1nodeconstants.nullid | ||||
| t = self._db.execute( | t = self._db.execute( | ||||
| 'SELECT node FROM changelog WHERE rev = ?', (r,) | 'SELECT node FROM changelog WHERE rev = ?', (r,) | ||||
| ).fetchone() | ).fetchone() | ||||
| if t is None: | if t is None: | ||||
| raise error.LookupError(r, b'00changelog.i', _(b'no node')) | raise error.LookupError(r, b'00changelog.i', _(b'no node')) | ||||
| return bin(t[0]) | return bin(t[0]) | ||||
| def hasnode(self, n): | def hasnode(self, n): | ||||
| return baselogindex(self) | return baselogindex(self) | ||||
| @property | @property | ||||
| def nodemap(self): | def nodemap(self): | ||||
| r = { | r = { | ||||
| bin(v[0]): v[1] | bin(v[0]): v[1] | ||||
| for v in self._db.execute('SELECT node, rev FROM changelog') | for v in self._db.execute('SELECT node, rev FROM changelog') | ||||
| } | } | ||||
| r[nullid] = nullrev | r[sha1nodeconstants.nullid] = nullrev | ||||
| return r | return r | ||||
| def tip(self): | def tip(self): | ||||
| t = self._db.execute( | t = self._db.execute( | ||||
| 'SELECT node FROM changelog ORDER BY rev DESC LIMIT 1' | 'SELECT node FROM changelog ORDER BY rev DESC LIMIT 1' | ||||
| ).fetchone() | ).fetchone() | ||||
| if t: | if t: | ||||
| return bin(t[0]) | return bin(t[0]) | ||||
| return nullid | return sha1nodeconstants.nullid | ||||
| def revs(self, start=0, stop=None): | def revs(self, start=0, stop=None): | ||||
| if stop is None: | if stop is None: | ||||
| stop = self.tip() | stop = self.tip() | ||||
| t = self._db.execute( | t = self._db.execute( | ||||
| 'SELECT rev FROM changelog ' | 'SELECT rev FROM changelog ' | ||||
| 'WHERE rev >= ? AND rev <= ? ' | 'WHERE rev >= ? AND rev <= ? ' | ||||
| 'ORDER BY REV ASC', | 'ORDER BY REV ASC', | ||||
| (start, stop), | (start, stop), | ||||
| ) | ) | ||||
| return (int(r[0]) for r in t) | return (int(r[0]) for r in t) | ||||
| def tiprev(self): | def tiprev(self): | ||||
| t = self._db.execute( | t = self._db.execute( | ||||
| 'SELECT rev FROM changelog ' 'ORDER BY REV DESC ' 'LIMIT 1' | 'SELECT rev FROM changelog ' 'ORDER BY REV DESC ' 'LIMIT 1' | ||||
| ) | ) | ||||
| return next(t) | return next(t) | ||||
| def _partialmatch(self, id): | def _partialmatch(self, id): | ||||
| if wdirhex.startswith(id): | if sha1nodeconstants.wdirhex.startswith(id): | ||||
| raise error.WdirUnsupported | raise error.WdirUnsupported | ||||
| candidates = [ | candidates = [ | ||||
| bin(x[0]) | bin(x[0]) | ||||
| for x in self._db.execute( | for x in self._db.execute( | ||||
| 'SELECT node FROM changelog WHERE node LIKE ?', (id + b'%',) | 'SELECT node FROM changelog WHERE node LIKE ?', (id + b'%',) | ||||
| ) | ) | ||||
| ] | ] | ||||
| if nullhex.startswith(id): | if sha1nodeconstants.nullhex.startswith(id): | ||||
| candidates.append(nullid) | candidates.append(sha1nodeconstants.nullid) | ||||
| if len(candidates) > 1: | if len(candidates) > 1: | ||||
| raise error.AmbiguousPrefixLookupError( | raise error.AmbiguousPrefixLookupError( | ||||
| id, b'00changelog.i', _(b'ambiguous identifier') | id, b'00changelog.i', _(b'ambiguous identifier') | ||||
| ) | ) | ||||
| if candidates: | if candidates: | ||||
| return candidates[0] | return candidates[0] | ||||
| return None | return None | ||||
| def changelogrevision(self, nodeorrev): | def changelogrevision(self, nodeorrev): | ||||
| # Ensure we have a node id | # Ensure we have a node id | ||||
| if isinstance(nodeorrev, int): | if isinstance(nodeorrev, int): | ||||
| n = self.node(nodeorrev) | n = self.node(nodeorrev) | ||||
| else: | else: | ||||
| n = nodeorrev | n = nodeorrev | ||||
| # handle looking up nullid | # handle looking up nullid | ||||
| if n == nullid: | if n == sha1nodeconstants.nullid: | ||||
| return hgchangelog._changelogrevision(extra={}, manifest=nullid) | return hgchangelog._changelogrevision( | ||||
| extra={}, manifest=sha1nodeconstants.nullid | |||||
| ) | |||||
| hn = gitutil.togitnode(n) | hn = gitutil.togitnode(n) | ||||
| # We've got a real commit! | # We've got a real commit! | ||||
| files = [ | files = [ | ||||
| r[0] | r[0] | ||||
| for r in self._db.execute( | for r in self._db.execute( | ||||
| 'SELECT filename FROM changedfiles ' | 'SELECT filename FROM changedfiles ' | ||||
| 'WHERE node = ? and filenode != ?', | 'WHERE node = ? and filenode != ?', | ||||
| (hn, gitutil.nullgit), | (hn, gitutil.nullgit), | ||||
| ) | ) | ||||
| ] | ] | ||||
| filesremoved = [ | filesremoved = [ | ||||
| r[0] | r[0] | ||||
| for r in self._db.execute( | for r in self._db.execute( | ||||
| 'SELECT filename FROM changedfiles ' | 'SELECT filename FROM changedfiles ' | ||||
| 'WHERE node = ? and filenode = ?', | 'WHERE node = ? and filenode = ?', | ||||
| (hn, nullhex), | (hn, sha1nodeconstants.nullhex), | ||||
| ) | ) | ||||
| ] | ] | ||||
| c = self.gitrepo[hn] | c = self.gitrepo[hn] | ||||
| return hgchangelog._changelogrevision( | return hgchangelog._changelogrevision( | ||||
| manifest=n, # pretend manifest the same as the commit node | manifest=n, # pretend manifest the same as the commit node | ||||
| user=b'%s <%s>' | user=b'%s <%s>' | ||||
| % (c.author.name.encode('utf8'), c.author.email.encode('utf8')), | % (c.author.name.encode('utf8'), c.author.email.encode('utf8')), | ||||
| date=(c.author.time, -c.author.offset * 60), | date=(c.author.time, -c.author.offset * 60), | ||||
| The list is sorted by revision number, meaning it is | The list is sorted by revision number, meaning it is | ||||
| topologically sorted. | topologically sorted. | ||||
| 'heads' and 'common' are both lists of node IDs. If heads is | 'heads' and 'common' are both lists of node IDs. If heads is | ||||
| not supplied, uses all of the revlog's heads. If common is not | not supplied, uses all of the revlog's heads. If common is not | ||||
| supplied, uses nullid.""" | supplied, uses nullid.""" | ||||
| if common is None: | if common is None: | ||||
| common = [nullid] | common = [sha1nodeconstants.nullid] | ||||
| if heads is None: | if heads is None: | ||||
| heads = self.heads() | heads = self.heads() | ||||
| common = [self.rev(n) for n in common] | common = [self.rev(n) for n in common] | ||||
| heads = [self.rev(n) for n in heads] | heads = [self.rev(n) for n in heads] | ||||
| inc = self.incrementalmissingrevs(common=common) | inc = self.incrementalmissingrevs(common=common) | ||||
| return [self.node(r) for r in inc.missingancestors(heads)] | return [self.node(r) for r in inc.missingancestors(heads)] | ||||
| extra=None, | extra=None, | ||||
| p1copies=None, | p1copies=None, | ||||
| p2copies=None, | p2copies=None, | ||||
| filesadded=None, | filesadded=None, | ||||
| filesremoved=None, | filesremoved=None, | ||||
| ): | ): | ||||
| parents = [] | parents = [] | ||||
| hp1, hp2 = gitutil.togitnode(p1), gitutil.togitnode(p2) | hp1, hp2 = gitutil.togitnode(p1), gitutil.togitnode(p2) | ||||
| if p1 != nullid: | if p1 != sha1nodeconstants.nullid: | ||||
| parents.append(hp1) | parents.append(hp1) | ||||
| if p2 and p2 != nullid: | if p2 and p2 != sha1nodeconstants.nullid: | ||||
| parents.append(hp2) | parents.append(hp2) | ||||
| assert date is not None | assert date is not None | ||||
| timestamp, tz = date | timestamp, tz = date | ||||
| sig = pygit2.Signature( | sig = pygit2.Signature( | ||||
| encoding.unifromlocal(stringutil.person(user)), | encoding.unifromlocal(stringutil.person(user)), | ||||
| encoding.unifromlocal(stringutil.email(user)), | encoding.unifromlocal(stringutil.email(user)), | ||||
| int(timestamp), | int(timestamp), | ||||
| -int(tz // 60), | -int(tz // 60), | ||||
| class manifestlog(baselog): | class manifestlog(baselog): | ||||
| nodeconstants = sha1nodeconstants | nodeconstants = sha1nodeconstants | ||||
| def __getitem__(self, node): | def __getitem__(self, node): | ||||
| return self.get(b'', node) | return self.get(b'', node) | ||||
| def get(self, relpath, node): | def get(self, relpath, node): | ||||
| if node == nullid: | if node == sha1nodeconstants.nullid: | ||||
| # TODO: this should almost certainly be a memgittreemanifestctx | # TODO: this should almost certainly be a memgittreemanifestctx | ||||
| return manifest.memtreemanifestctx(self, relpath) | return manifest.memtreemanifestctx(self, relpath) | ||||
| commit = self.gitrepo[gitutil.togitnode(node)] | commit = self.gitrepo[gitutil.togitnode(node)] | ||||
| t = commit.tree | t = commit.tree | ||||
| if relpath: | if relpath: | ||||
| parts = relpath.split(b'/') | parts = relpath.split(b'/') | ||||
| for p in parts: | for p in parts: | ||||
| te = t[p] | te = t[p] | ||||
| t = self.gitrepo[te.id] | t = self.gitrepo[te.id] | ||||
| return gitmanifest.gittreemanifestctx(self.gitrepo, t) | return gitmanifest.gittreemanifestctx(self.gitrepo, t) | ||||
| @interfaceutil.implementer(repository.ifilestorage) | @interfaceutil.implementer(repository.ifilestorage) | ||||
| class filelog(baselog): | class filelog(baselog): | ||||
| def __init__(self, gr, db, path): | def __init__(self, gr, db, path): | ||||
| super(filelog, self).__init__(gr, db) | super(filelog, self).__init__(gr, db) | ||||
| assert isinstance(path, bytes) | assert isinstance(path, bytes) | ||||
| self.path = path | self.path = path | ||||
| self.nullid = sha1nodeconstants.nullid | |||||
| def read(self, node): | def read(self, node): | ||||
| if node == nullid: | if node == sha1nodeconstants.nullid: | ||||
| return b'' | return b'' | ||||
| return self.gitrepo[gitutil.togitnode(node)].data | return self.gitrepo[gitutil.togitnode(node)].data | ||||
| def lookup(self, node): | def lookup(self, node): | ||||
| if len(node) not in (20, 40): | if len(node) not in (20, 40): | ||||
| node = int(node) | node = int(node) | ||||
| if isinstance(node, int): | if isinstance(node, int): | ||||
| assert False, b'todo revnums for nodes' | assert False, b'todo revnums for nodes' | ||||
| """utilities to assist in working with pygit2""" | """utilities to assist in working with pygit2""" | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from mercurial.node import bin, hex, nullid | from mercurial.node import bin, hex, sha1nodeconstants | ||||
| from mercurial import pycompat | from mercurial import pycompat | ||||
| pygit2_module = None | pygit2_module = None | ||||
| def get_pygit2(): | def get_pygit2(): | ||||
| global pygit2_module | global pygit2_module | ||||
| def fromgitnode(n): | def fromgitnode(n): | ||||
| """Opposite of togitnode.""" | """Opposite of togitnode.""" | ||||
| assert len(n) == 40 | assert len(n) == 40 | ||||
| if pycompat.ispy3: | if pycompat.ispy3: | ||||
| return bin(n.encode('ascii')) | return bin(n.encode('ascii')) | ||||
| return bin(n) | return bin(n) | ||||
| nullgit = togitnode(nullid) | nullgit = togitnode(sha1nodeconstants.nullid) | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import os | import os | ||||
| import sqlite3 | import sqlite3 | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import sha1nodeconstants | ||||
| nullhex, | |||||
| nullid, | |||||
| ) | |||||
| from mercurial import ( | from mercurial import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| pycompat, | pycompat, | ||||
| ) | ) | ||||
| from . import gitutil | from . import gitutil | ||||
| if prog is not None: | if prog is not None: | ||||
| prog.complete() | prog.complete() | ||||
| prog = progress_factory(b'commits') | prog = progress_factory(b'commits') | ||||
| # This walker is sure to visit all the revisions in history, but | # This walker is sure to visit all the revisions in history, but | ||||
| # only once. | # only once. | ||||
| for pos, commit in enumerate(walker): | for pos, commit in enumerate(walker): | ||||
| if prog is not None: | if prog is not None: | ||||
| prog.update(pos) | prog.update(pos) | ||||
| p1 = p2 = nullhex | p1 = p2 = sha1nodeconstants.nullhex | ||||
| if len(commit.parents) > 2: | if len(commit.parents) > 2: | ||||
| raise error.ProgrammingError( | raise error.ProgrammingError( | ||||
| ( | ( | ||||
| b"git support can't handle octopus merges, " | b"git support can't handle octopus merges, " | ||||
| b"found a commit with %d parents :(" | b"found a commit with %d parents :(" | ||||
| ) | ) | ||||
| % len(commit.parents) | % len(commit.parents) | ||||
| ) | ) | ||||
| if p1 is not None: | if p1 is not None: | ||||
| patchgen = gitrepo.diff(p1, commit.id.hex, flags=_DIFF_FLAGS) | patchgen = gitrepo.diff(p1, commit.id.hex, flags=_DIFF_FLAGS) | ||||
| else: | else: | ||||
| patchgen = commit.tree.diff_to_tree( | patchgen = commit.tree.diff_to_tree( | ||||
| swap=True, flags=_DIFF_FLAGS | swap=True, flags=_DIFF_FLAGS | ||||
| ) | ) | ||||
| new_files = (p.delta.new_file for p in patchgen) | new_files = (p.delta.new_file for p in patchgen) | ||||
| files = { | files = { | ||||
| nf.path: nf.id.hex for nf in new_files if nf.id.raw != nullid | nf.path: nf.id.hex | ||||
| for nf in new_files | |||||
| if nf.id.raw != sha1nodeconstants.nullid | |||||
| } | } | ||||
| for p, n in files.items(): | for p, n in files.items(): | ||||
| # We intentionally set NULLs for any file parentage | # We intentionally set NULLs for any file parentage | ||||
| # information so it'll get demand-computed later. We | # information so it'll get demand-computed later. We | ||||
| # used to do it right here, and it was _very_ slow. | # used to do it right here, and it was _very_ slow. | ||||
| db.execute( | db.execute( | ||||
| 'INSERT INTO changedfiles (' | 'INSERT INTO changedfiles (' | ||||
| 'node, filename, filenode, p1node, p1filenode, p2node, ' | 'node, filename, filenode, p1node, p1filenode, p2node, ' | ||||
| # Copyright 2005, 2006 Benoit Boissinot <benoit.boissinot@ens-lyon.org> | # Copyright 2005, 2006 Benoit Boissinot <benoit.boissinot@ens-lyon.org> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| '''commands to sign and verify changesets''' | '''commands to sign and verify changesets''' | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import binascii | import binascii | ||||
| import os | import os | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| short, | short, | ||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| cmdutil, | cmdutil, | ||||
| error, | error, | ||||
| help, | help, | ||||
| match, | match, | ||||
| pycompat, | pycompat, | ||||
| date = opts.get(b'date') | date = opts.get(b'date') | ||||
| if date: | if date: | ||||
| opts[b'date'] = dateutil.parsedate(date) | opts[b'date'] = dateutil.parsedate(date) | ||||
| if revs: | if revs: | ||||
| nodes = [repo.lookup(n) for n in revs] | nodes = [repo.lookup(n) for n in revs] | ||||
| else: | else: | ||||
| nodes = [node for node in repo.dirstate.parents() if node != nullid] | nodes = [ | ||||
| node for node in repo.dirstate.parents() if node != repo.nullid | |||||
| ] | |||||
| if len(nodes) > 1: | if len(nodes) > 1: | ||||
| raise error.Abort( | raise error.Abort( | ||||
| _(b'uncommitted merge - please provide a specific revision') | _(b'uncommitted merge - please provide a specific revision') | ||||
| ) | ) | ||||
| if not nodes: | if not nodes: | ||||
| nodes = [repo.changelog.tip()] | nodes = [repo.changelog.tip()] | ||||
| for n in nodes: | for n in nodes: | ||||
| ''' | ''' | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import os | import os | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| commands, | commands, | ||||
| obsolete, | obsolete, | ||||
| patch, | patch, | ||||
| pycompat, | pycompat, | ||||
| def __difftree(repo, node1, node2, files=None): | def __difftree(repo, node1, node2, files=None): | ||||
| assert node2 is not None | assert node2 is not None | ||||
| if files is None: | if files is None: | ||||
| files = [] | files = [] | ||||
| mmap = repo[node1].manifest() | mmap = repo[node1].manifest() | ||||
| mmap2 = repo[node2].manifest() | mmap2 = repo[node2].manifest() | ||||
| m = scmutil.match(repo[node1], files) | m = scmutil.match(repo[node1], files) | ||||
| st = repo.status(node1, node2, m) | st = repo.status(node1, node2, m) | ||||
| empty = short(nullid) | empty = short(repo.nullid) | ||||
| for f in st.modified: | for f in st.modified: | ||||
| # TODO get file permissions | # TODO get file permissions | ||||
| ui.writenoi18n( | ui.writenoi18n( | ||||
| b":100664 100664 %s %s M\t%s\t%s\n" | b":100664 100664 %s %s M\t%s\t%s\n" | ||||
| % (short(mmap[f]), short(mmap2[f]), f, f) | % (short(mmap[f]), short(mmap2[f]), f, f) | ||||
| ) | ) | ||||
| for f in st.added: | for f in st.added: | ||||
| if i not in repo: | if i not in repo: | ||||
| continue | continue | ||||
| n = repo.changelog.node(i) | n = repo.changelog.node(i) | ||||
| mask = is_reachable(want_sha1, reachable, n) | mask = is_reachable(want_sha1, reachable, n) | ||||
| if mask: | if mask: | ||||
| parentstr = b"" | parentstr = b"" | ||||
| if parents: | if parents: | ||||
| pp = repo.changelog.parents(n) | pp = repo.changelog.parents(n) | ||||
| if pp[0] != nullid: | if pp[0] != repo.nullid: | ||||
| parentstr += b" " + short(pp[0]) | parentstr += b" " + short(pp[0]) | ||||
| if pp[1] != nullid: | if pp[1] != repo.nullid: | ||||
| parentstr += b" " + short(pp[1]) | parentstr += b" " + short(pp[1]) | ||||
| if not full: | if not full: | ||||
| ui.write(b"%s%s\n" % (short(n), parentstr)) | ui.write(b"%s%s\n" % (short(n), parentstr)) | ||||
| elif full == b"commit": | elif full == b"commit": | ||||
| ui.write(b"%s%s\n" % (short(n), parentstr)) | ui.write(b"%s%s\n" % (short(n), parentstr)) | ||||
| catcommit(ui, repo, n, b' ', ctx) | catcommit(ui, repo, n, b' ', ctx) | ||||
| else: | else: | ||||
| (p1, p2) = repo.changelog.parents(n) | (p1, p2) = repo.changelog.parents(n) | ||||
| import errno | import errno | ||||
| import os | import os | ||||
| import weakref | import weakref | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| bookmarks, | bookmarks, | ||||
| cmdutil, | cmdutil, | ||||
| dispatch, | dispatch, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| def recorddirstateparents(dirstate, old, new): | def recorddirstateparents(dirstate, old, new): | ||||
| """Records all dirstate parent changes in the journal.""" | """Records all dirstate parent changes in the journal.""" | ||||
| old = list(old) | old = list(old) | ||||
| new = list(new) | new = list(new) | ||||
| if util.safehasattr(dirstate, 'journalstorage'): | if util.safehasattr(dirstate, 'journalstorage'): | ||||
| # only record two hashes if there was a merge | # only record two hashes if there was a merge | ||||
| oldhashes = old[:1] if old[1] == nullid else old | oldhashes = old[:1] if old[1] == dirstate._nodeconstants.nullid else old | ||||
| newhashes = new[:1] if new[1] == nullid else new | newhashes = new[:1] if new[1] == dirstate._nodeconstants.nullid else new | ||||
| dirstate.journalstorage.record( | dirstate.journalstorage.record( | ||||
| wdirparenttype, b'.', oldhashes, newhashes | wdirparenttype, b'.', oldhashes, newhashes | ||||
| ) | ) | ||||
| # hooks to record bookmark changes (both local and remote) | # hooks to record bookmark changes (both local and remote) | ||||
| def recordbookmarks(orig, store, fp): | def recordbookmarks(orig, store, fp): | ||||
| """Records all bookmark changes in the journal.""" | """Records all bookmark changes in the journal.""" | ||||
| repo = store._repo | repo = store._repo | ||||
| if util.safehasattr(repo, 'journal'): | if util.safehasattr(repo, 'journal'): | ||||
| oldmarks = bookmarks.bmstore(repo) | oldmarks = bookmarks.bmstore(repo) | ||||
| for mark, value in pycompat.iteritems(store): | for mark, value in pycompat.iteritems(store): | ||||
| oldvalue = oldmarks.get(mark, nullid) | oldvalue = oldmarks.get(mark, repo.nullid) | ||||
| if value != oldvalue: | if value != oldvalue: | ||||
| repo.journal.record(bookmarktype, mark, oldvalue, value) | repo.journal.record(bookmarktype, mark, oldvalue, value) | ||||
| return orig(store, fp) | return orig(store, fp) | ||||
| # shared repository support | # shared repository support | ||||
| def _readsharedfeatures(repo): | def _readsharedfeatures(repo): | ||||
| """A set of shared features for this repository""" | """A set of shared features for this repository""" | ||||
| # Copyright 2009-2010 Gregory P. Ward | # Copyright 2009-2010 Gregory P. Ward | ||||
| # Copyright 2009-2010 Intelerad Medical Systems Incorporated | # Copyright 2009-2010 Intelerad Medical Systems Incorporated | ||||
| # Copyright 2010-2011 Fog Creek Software | # Copyright 2010-2011 Fog Creek Software | ||||
| # Copyright 2010-2011 Unity Technologies | # Copyright 2010-2011 Unity Technologies | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| '''base class for store implementations and store-related utility code''' | '''base class for store implementations and store-related utility code''' | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial import node, util | from mercurial.node import short | ||||
| from mercurial import util | |||||
| from mercurial.utils import ( | from mercurial.utils import ( | ||||
| urlutil, | urlutil, | ||||
| ) | ) | ||||
| from . import lfutil | from . import lfutil | ||||
| class StoreError(Exception): | class StoreError(Exception): | ||||
| self.ui.status( | self.ui.status( | ||||
| _(b'searching %d changesets for largefiles\n') % len(revs) | _(b'searching %d changesets for largefiles\n') % len(revs) | ||||
| ) | ) | ||||
| verified = set() # set of (filename, filenode) tuples | verified = set() # set of (filename, filenode) tuples | ||||
| filestocheck = [] # list of (cset, filename, expectedhash) | filestocheck = [] # list of (cset, filename, expectedhash) | ||||
| for rev in revs: | for rev in revs: | ||||
| cctx = self.repo[rev] | cctx = self.repo[rev] | ||||
| cset = b"%d:%s" % (cctx.rev(), node.short(cctx.node())) | cset = b"%d:%s" % (cctx.rev(), short(cctx.node())) | ||||
| for standin in cctx: | for standin in cctx: | ||||
| filename = lfutil.splitstandin(standin) | filename = lfutil.splitstandin(standin) | ||||
| if filename: | if filename: | ||||
| fctx = cctx[standin] | fctx = cctx[standin] | ||||
| key = (filename, fctx.filenode()) | key = (filename, fctx.filenode()) | ||||
| if key not in verified: | if key not in verified: | ||||
| verified.add(key) | verified.add(key) | ||||
| import errno | import errno | ||||
| import os | import os | ||||
| import shutil | import shutil | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| cmdutil, | cmdutil, | ||||
| context, | context, | ||||
| error, | error, | ||||
| exthelper, | exthelper, | ||||
| hg, | hg, | ||||
| # Get a list of all changesets in the source. The easy way to do this | # Get a list of all changesets in the source. The easy way to do this | ||||
| # is to simply walk the changelog, using changelog.nodesbetween(). | # is to simply walk the changelog, using changelog.nodesbetween(). | ||||
| # Take a look at mercurial/revlog.py:639 for more details. | # Take a look at mercurial/revlog.py:639 for more details. | ||||
| # Use a generator instead of a list to decrease memory usage | # Use a generator instead of a list to decrease memory usage | ||||
| ctxs = ( | ctxs = ( | ||||
| rsrc[ctx] | rsrc[ctx] | ||||
| for ctx in rsrc.changelog.nodesbetween(None, rsrc.heads())[0] | for ctx in rsrc.changelog.nodesbetween(None, rsrc.heads())[0] | ||||
| ) | ) | ||||
| revmap = {nullid: nullid} | revmap = {rsrc.nullid: rdst.nullid} | ||||
| if tolfile: | if tolfile: | ||||
| # Lock destination to prevent modification while it is converted to. | # Lock destination to prevent modification while it is converted to. | ||||
| # Don't need to lock src because we are just reading from its | # Don't need to lock src because we are just reading from its | ||||
| # history which can't change. | # history which can't change. | ||||
| dstwlock = rdst.wlock() | dstwlock = rdst.wlock() | ||||
| dstlock = rdst.lock() | dstlock = rdst.lock() | ||||
| lfiles = set() | lfiles = set() | ||||
| lfutil.copyalltostore(rdst, ret) | lfutil.copyalltostore(rdst, ret) | ||||
| rdst.setparents(ret) | rdst.setparents(ret) | ||||
| revmap[ctx.node()] = rdst.changelog.tip() | revmap[ctx.node()] = rdst.changelog.tip() | ||||
| # Generate list of changed files | # Generate list of changed files | ||||
| def _getchangedfiles(ctx, parents): | def _getchangedfiles(ctx, parents): | ||||
| files = set(ctx.files()) | files = set(ctx.files()) | ||||
| if nullid not in parents: | if ctx.repo().nullid not in parents: | ||||
| mc = ctx.manifest() | mc = ctx.manifest() | ||||
| for pctx in ctx.parents(): | for pctx in ctx.parents(): | ||||
| for fn in pctx.manifest().diff(mc): | for fn in pctx.manifest().diff(mc): | ||||
| files.add(fn) | files.add(fn) | ||||
| return files | return files | ||||
| # Convert src parents to dst parents | # Convert src parents to dst parents | ||||
| def _convertparents(ctx, revmap): | def _convertparents(ctx, revmap): | ||||
| parents = [] | parents = [] | ||||
| for p in ctx.parents(): | for p in ctx.parents(): | ||||
| parents.append(revmap[p.node()]) | parents.append(revmap[p.node()]) | ||||
| while len(parents) < 2: | while len(parents) < 2: | ||||
| parents.append(nullid) | parents.append(ctx.repo().nullid) | ||||
| return parents | return parents | ||||
| # Get memfilectx for a normal file | # Get memfilectx for a normal file | ||||
| def _getnormalcontext(repo, ctx, f, revmap): | def _getnormalcontext(repo, ctx, f, revmap): | ||||
| try: | try: | ||||
| fctx = ctx.filectx(f) | fctx = ctx.filectx(f) | ||||
| except error.LookupError: | except error.LookupError: | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import contextlib | import contextlib | ||||
| import copy | import copy | ||||
| import os | import os | ||||
| import stat | import stat | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import hex | ||||
| hex, | |||||
| nullid, | |||||
| ) | |||||
| from mercurial.pycompat import open | from mercurial.pycompat import open | ||||
| from mercurial import ( | from mercurial import ( | ||||
| dirstate, | dirstate, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| httpconnection, | httpconnection, | ||||
| match as matchmod, | match as matchmod, | ||||
| makeprogress = repo.ui.makeprogress | makeprogress = repo.ui.makeprogress | ||||
| with makeprogress( | with makeprogress( | ||||
| _(b'finding outgoing largefiles'), | _(b'finding outgoing largefiles'), | ||||
| unit=_(b'revisions'), | unit=_(b'revisions'), | ||||
| total=len(missing), | total=len(missing), | ||||
| ) as progress: | ) as progress: | ||||
| for i, n in enumerate(missing): | for i, n in enumerate(missing): | ||||
| progress.update(i) | progress.update(i) | ||||
| parents = [p for p in repo[n].parents() if p != nullid] | parents = [p for p in repo[n].parents() if p != repo.nullid] | ||||
| with lfstatus(repo, value=False): | with lfstatus(repo, value=False): | ||||
| ctx = repo[n] | ctx = repo[n] | ||||
| files = set(ctx.files()) | files = set(ctx.files()) | ||||
| if len(parents) == 2: | if len(parents) == 2: | ||||
| mc = ctx.manifest() | mc = ctx.manifest() | ||||
| mp1 = ctx.p1().manifest() | mp1 = ctx.p1().manifest() | ||||
| # wrapper.py - methods wrapping core mercurial logic | # wrapper.py - methods wrapping core mercurial logic | ||||
| # | # | ||||
| # Copyright 2017 Facebook, Inc. | # Copyright 2017 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import hashlib | import hashlib | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import bin, hex, nullid, short | from mercurial.node import bin, hex, short | ||||
| from mercurial.pycompat import ( | from mercurial.pycompat import ( | ||||
| getattr, | getattr, | ||||
| setattr, | setattr, | ||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| bundle2, | bundle2, | ||||
| changegroup, | changegroup, | ||||
| def _islfs(rlog, node=None, rev=None): | def _islfs(rlog, node=None, rev=None): | ||||
| if rev is None: | if rev is None: | ||||
| if node is None: | if node is None: | ||||
| # both None - likely working copy content where node is not ready | # both None - likely working copy content where node is not ready | ||||
| return False | return False | ||||
| rev = rlog.rev(node) | rev = rlog.rev(node) | ||||
| else: | else: | ||||
| node = rlog.node(rev) | node = rlog.node(rev) | ||||
| if node == nullid: | if node == rlog.nullid: | ||||
| return False | return False | ||||
| flags = rlog.flags(rev) | flags = rlog.flags(rev) | ||||
| return bool(flags & revlog.REVIDX_EXTSTORED) | return bool(flags & revlog.REVIDX_EXTSTORED) | ||||
| # Wrapping may also be applied by remotefilelog | # Wrapping may also be applied by remotefilelog | ||||
| def filelogaddrevision( | def filelogaddrevision( | ||||
| orig, | orig, | ||||
| import os | import os | ||||
| import re | import re | ||||
| import shutil | import shutil | ||||
| import sys | import sys | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from mercurial.pycompat import ( | from mercurial.pycompat import ( | ||||
| delattr, | delattr, | ||||
| getattr, | getattr, | ||||
| open, | open, | ||||
| ) | ) | ||||
| In some case where mq get himself in being the parent of a merge the | In some case where mq get himself in being the parent of a merge the | ||||
| appropriate parent may be p2. | appropriate parent may be p2. | ||||
| (eg: an in progress merge started with mq disabled) | (eg: an in progress merge started with mq disabled) | ||||
| If no parent are managed by mq, p1 is returned. | If no parent are managed by mq, p1 is returned. | ||||
| """ | """ | ||||
| if rev is None: | if rev is None: | ||||
| (p1, p2) = repo.dirstate.parents() | (p1, p2) = repo.dirstate.parents() | ||||
| if p2 == nullid: | if p2 == repo.nullid: | ||||
| return p1 | return p1 | ||||
| if not self.applied: | if not self.applied: | ||||
| return None | return None | ||||
| return self.applied[-1].node | return self.applied[-1].node | ||||
| p1, p2 = repo.changelog.parents(rev) | p1, p2 = repo.changelog.parents(rev) | ||||
| if p2 != nullid and p2 in [x.node for x in self.applied]: | if p2 != repo.nullid and p2 in [x.node for x in self.applied]: | ||||
| return p2 | return p2 | ||||
| return p1 | return p1 | ||||
| def mergepatch(self, repo, mergeq, series, diffopts): | def mergepatch(self, repo, mergeq, series, diffopts): | ||||
| if not self.applied: | if not self.applied: | ||||
| # each of the patches merged in will have two parents. This | # each of the patches merged in will have two parents. This | ||||
| # can confuse the qrefresh, qdiff, and strip code because it | # can confuse the qrefresh, qdiff, and strip code because it | ||||
| # needs to know which parent is actually in the patch queue. | # needs to know which parent is actually in the patch queue. | ||||
| ): | ): | ||||
| self.checkkeepchanges(keepchanges, force) | self.checkkeepchanges(keepchanges, force) | ||||
| diffopts = self.diffopts() | diffopts = self.diffopts() | ||||
| with repo.wlock(): | with repo.wlock(): | ||||
| heads = [] | heads = [] | ||||
| for hs in repo.branchmap().iterheads(): | for hs in repo.branchmap().iterheads(): | ||||
| heads.extend(hs) | heads.extend(hs) | ||||
| if not heads: | if not heads: | ||||
| heads = [nullid] | heads = [repo.nullid] | ||||
| if repo.dirstate.p1() not in heads and not exact: | if repo.dirstate.p1() not in heads and not exact: | ||||
| self.ui.status(_(b"(working directory not at a head)\n")) | self.ui.status(_(b"(working directory not at a head)\n")) | ||||
| if not self.series: | if not self.series: | ||||
| self.ui.warn(_(b'no patches in series\n')) | self.ui.warn(_(b'no patches in series\n')) | ||||
| return 0 | return 0 | ||||
| # Suppose our series file is: A B C and the current 'top' | # Suppose our series file is: A B C and the current 'top' | ||||
| with repo.dirstate.parentchange(): | with repo.dirstate.parentchange(): | ||||
| for f in a: | for f in a: | ||||
| repo.wvfs.unlinkpath(f, ignoremissing=True) | repo.wvfs.unlinkpath(f, ignoremissing=True) | ||||
| repo.dirstate.drop(f) | repo.dirstate.drop(f) | ||||
| for f in m + r: | for f in m + r: | ||||
| fctx = ctx[f] | fctx = ctx[f] | ||||
| repo.wwrite(f, fctx.data(), fctx.flags()) | repo.wwrite(f, fctx.data(), fctx.flags()) | ||||
| repo.dirstate.normal(f) | repo.dirstate.normal(f) | ||||
| repo.setparents(qp, nullid) | repo.setparents(qp, repo.nullid) | ||||
| for patch in reversed(self.applied[start:end]): | for patch in reversed(self.applied[start:end]): | ||||
| self.ui.status(_(b"popping %s\n") % patch.name) | self.ui.status(_(b"popping %s\n") % patch.name) | ||||
| del self.applied[start:end] | del self.applied[start:end] | ||||
| strip(self.ui, repo, [rev], update=False, backup=False) | strip(self.ui, repo, [rev], update=False, backup=False) | ||||
| for s, state in repo[b'.'].substate.items(): | for s, state in repo[b'.'].substate.items(): | ||||
| repo[b'.'].sub(s).get(state) | repo[b'.'].sub(s).get(state) | ||||
| if self.applied: | if self.applied: | ||||
| self.ui.write(_(b"now at: %s\n") % self.applied[-1].name) | self.ui.write(_(b"now at: %s\n") % self.applied[-1].name) | ||||
| # narrowbundle2.py - bundle2 extensions for narrow repository support | # narrowbundle2.py - bundle2 extensions for narrow repository support | ||||
| # | # | ||||
| # Copyright 2017 Google, Inc. | # Copyright 2017 Google, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import errno | import errno | ||||
| import struct | import struct | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import nullid | |||||
| from mercurial import ( | from mercurial import ( | ||||
| bundle2, | bundle2, | ||||
| changegroup, | changegroup, | ||||
| error, | error, | ||||
| exchange, | exchange, | ||||
| localrepo, | localrepo, | ||||
| narrowspec, | narrowspec, | ||||
| repair, | repair, | ||||
| ): | ): | ||||
| match = narrowspec.match(repo.root, include=include, exclude=exclude) | match = narrowspec.match(repo.root, include=include, exclude=exclude) | ||||
| if depth is not None: | if depth is not None: | ||||
| depth = int(depth) | depth = int(depth) | ||||
| if depth < 1: | if depth < 1: | ||||
| raise error.Abort(_(b'depth must be positive, got %d') % depth) | raise error.Abort(_(b'depth must be positive, got %d') % depth) | ||||
| heads = set(heads or repo.heads()) | heads = set(heads or repo.heads()) | ||||
| common = set(common or [nullid]) | common = set(common or [repo.nullid]) | ||||
| visitnodes, relevant_nodes, ellipsisroots = exchange._computeellipsis( | visitnodes, relevant_nodes, ellipsisroots = exchange._computeellipsis( | ||||
| repo, common, heads, set(), match, depth=depth | repo, common, heads, set(), match, depth=depth | ||||
| ) | ) | ||||
| repo.ui.debug(b'Found %d relevant revs\n' % len(relevant_nodes)) | repo.ui.debug(b'Found %d relevant revs\n' % len(relevant_nodes)) | ||||
| if visitnodes: | if visitnodes: | ||||
| packer = changegroup.getbundler( | packer = changegroup.getbundler( | ||||
| bundler, | bundler, | ||||
| repo, | repo, | ||||
| oldmatch, | oldmatch, | ||||
| newmatch, | newmatch, | ||||
| version, | version, | ||||
| common, | common, | ||||
| known, | known, | ||||
| ): | ): | ||||
| common = set(common or [nullid]) | common = set(common or [repo.nullid]) | ||||
| # Steps: | # Steps: | ||||
| # 1. Send kill for "$known & ::common" | # 1. Send kill for "$known & ::common" | ||||
| # | # | ||||
| # 2. Send changegroup for ::common | # 2. Send changegroup for ::common | ||||
| # | # | ||||
| # 3. Proceed. | # 3. Proceed. | ||||
| # | # | ||||
| # In the future, we can send kills for only the specific | # In the future, we can send kills for only the specific | ||||
| # narrowcommands.py - command modifications for narrowhg extension | # narrowcommands.py - command modifications for narrowhg extension | ||||
| # | # | ||||
| # Copyright 2017 Google, Inc. | # Copyright 2017 Google, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import itertools | import itertools | ||||
| import os | import os | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| short, | short, | ||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| bundle2, | bundle2, | ||||
| cmdutil, | cmdutil, | ||||
| commands, | commands, | ||||
| discovery, | discovery, | ||||
| encoding, | encoding, | ||||
| if exclude: | if exclude: | ||||
| kwargs[b'excludepats'] = exclude | kwargs[b'excludepats'] = exclude | ||||
| # calculate known nodes only in ellipses cases because in non-ellipses cases | # calculate known nodes only in ellipses cases because in non-ellipses cases | ||||
| # we have all the nodes | # we have all the nodes | ||||
| if wireprototypes.ELLIPSESCAP1 in pullop.remote.capabilities(): | if wireprototypes.ELLIPSESCAP1 in pullop.remote.capabilities(): | ||||
| kwargs[b'known'] = [ | kwargs[b'known'] = [ | ||||
| hex(ctx.node()) | hex(ctx.node()) | ||||
| for ctx in repo.set(b'::%ln', pullop.common) | for ctx in repo.set(b'::%ln', pullop.common) | ||||
| if ctx.node() != nullid | if ctx.node() != repo.nullid | ||||
| ] | ] | ||||
| if not kwargs[b'known']: | if not kwargs[b'known']: | ||||
| # Mercurial serializes an empty list as '' and deserializes it as | # Mercurial serializes an empty list as '' and deserializes it as | ||||
| # [''], so delete it instead to avoid handling the empty string on | # [''], so delete it instead to avoid handling the empty string on | ||||
| # the server. | # the server. | ||||
| del kwargs[b'known'] | del kwargs[b'known'] | ||||
| overrides = {(b'devel', b'all-warnings'): False} | overrides = {(b'devel', b'all-warnings'): False} | ||||
| common = commoninc[0] | common = commoninc[0] | ||||
| with ui.uninterruptible(): | with ui.uninterruptible(): | ||||
| if ellipsesremote: | if ellipsesremote: | ||||
| ds = repo.dirstate | ds = repo.dirstate | ||||
| p1, p2 = ds.p1(), ds.p2() | p1, p2 = ds.p1(), ds.p2() | ||||
| with ds.parentchange(): | with ds.parentchange(): | ||||
| ds.setparents(nullid, nullid) | ds.setparents(repo.nullid, repo.nullid) | ||||
| if isoldellipses: | if isoldellipses: | ||||
| with wrappedextraprepare: | with wrappedextraprepare: | ||||
| exchange.pull(repo, remote, heads=common) | exchange.pull(repo, remote, heads=common) | ||||
| else: | else: | ||||
| known = [] | known = [] | ||||
| if ellipsesremote: | if ellipsesremote: | ||||
| known = [ | known = [ | ||||
| ctx.node() | ctx.node() | ||||
| for ctx in repo.set(b'::%ln', common) | for ctx in repo.set(b'::%ln', common) | ||||
| if ctx.node() != nullid | if ctx.node() != repo.nullid | ||||
| ] | ] | ||||
| with remote.commandexecutor() as e: | with remote.commandexecutor() as e: | ||||
| bundle = e.callcommand( | bundle = e.callcommand( | ||||
| b'narrow_widen', | b'narrow_widen', | ||||
| { | { | ||||
| b'oldincludes': oldincludes, | b'oldincludes': oldincludes, | ||||
| b'oldexcludes': oldexcludes, | b'oldexcludes': oldexcludes, | ||||
| b'newincludes': newincludes, | b'newincludes': newincludes, | ||||
| import hashlib | import hashlib | ||||
| import itertools | import itertools | ||||
| import json | import json | ||||
| import mimetypes | import mimetypes | ||||
| import operator | import operator | ||||
| import re | import re | ||||
| import time | import time | ||||
| from mercurial.node import bin, nullid, short | from mercurial.node import bin, short | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.pycompat import getattr | from mercurial.pycompat import getattr | ||||
| from mercurial.thirdparty import attr | from mercurial.thirdparty import attr | ||||
| from mercurial import ( | from mercurial import ( | ||||
| cmdutil, | cmdutil, | ||||
| context, | context, | ||||
| copies, | copies, | ||||
| encoding, | encoding, | ||||
| # Ignore if precursors (Phabricator and local repo) do not overlap, | # Ignore if precursors (Phabricator and local repo) do not overlap, | ||||
| # and force is not set (when commit message says nothing) | # and force is not set (when commit message says nothing) | ||||
| if not force and not phprecset: | if not force and not phprecset: | ||||
| tagname = b'D%d' % drev | tagname = b'D%d' % drev | ||||
| tags.tag( | tags.tag( | ||||
| repo, | repo, | ||||
| tagname, | tagname, | ||||
| nullid, | repo.nullid, | ||||
| message=None, | message=None, | ||||
| user=None, | user=None, | ||||
| date=None, | date=None, | ||||
| local=True, | local=True, | ||||
| ) | ) | ||||
| unfi.ui.warn( | unfi.ui.warn( | ||||
| _( | _( | ||||
| b'D%d: local tag removed - does not match ' | b'D%d: local tag removed - does not match ' | ||||
| ) | ) | ||||
| # Remove local tags since it's no longer necessary | # Remove local tags since it's no longer necessary | ||||
| tagname = b'D%d' % drevid | tagname = b'D%d' % drevid | ||||
| if tagname in repo.tags(): | if tagname in repo.tags(): | ||||
| tags.tag( | tags.tag( | ||||
| repo, | repo, | ||||
| tagname, | tagname, | ||||
| nullid, | repo.nullid, | ||||
| message=None, | message=None, | ||||
| user=None, | user=None, | ||||
| date=None, | date=None, | ||||
| local=True, | local=True, | ||||
| ) | ) | ||||
| elif fold: | elif fold: | ||||
| # When folding multiple commits into one review with | # When folding multiple commits into one review with | ||||
| # --fold, track even the commits that weren't amended, so | # --fold, track even the commits that weren't amended, so | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import threading | import threading | ||||
| from mercurial.node import hex, nullid | from mercurial.node import ( | ||||
| hex, | |||||
| sha1nodeconstants, | |||||
| ) | |||||
| from mercurial.pycompat import getattr | from mercurial.pycompat import getattr | ||||
| from mercurial import ( | from mercurial import ( | ||||
| mdiff, | mdiff, | ||||
| pycompat, | pycompat, | ||||
| revlog, | revlog, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| basestore, | basestore, | ||||
| """Fetches the full text revision contents of the given name+node pair. | """Fetches the full text revision contents of the given name+node pair. | ||||
| If the full text doesn't exist, throws a KeyError. | If the full text doesn't exist, throws a KeyError. | ||||
| Under the hood, this uses getdeltachain() across all the stores to build | Under the hood, this uses getdeltachain() across all the stores to build | ||||
| up a full chain to produce the full text. | up a full chain to produce the full text. | ||||
| """ | """ | ||||
| chain = self.getdeltachain(name, node) | chain = self.getdeltachain(name, node) | ||||
| if chain[-1][ChainIndicies.BASENODE] != nullid: | if chain[-1][ChainIndicies.BASENODE] != sha1nodeconstants.nullid: | ||||
| # If we didn't receive a full chain, throw | # If we didn't receive a full chain, throw | ||||
| raise KeyError((name, hex(node))) | raise KeyError((name, hex(node))) | ||||
| # The last entry in the chain is a full text, so we start our delta | # The last entry in the chain is a full text, so we start our delta | ||||
| # applies with that. | # applies with that. | ||||
| fulltext = chain.pop()[ChainIndicies.DATA] | fulltext = chain.pop()[ChainIndicies.DATA] | ||||
| text = fulltext | text = fulltext | ||||
| Returns an ordered list of: | Returns an ordered list of: | ||||
| [(name, node, deltabasename, deltabasenode, deltacontent),...] | [(name, node, deltabasename, deltabasenode, deltacontent),...] | ||||
| where the chain is terminated by a full text entry with a nullid | where the chain is terminated by a full text entry with a nullid | ||||
| deltabasenode. | deltabasenode. | ||||
| """ | """ | ||||
| chain = self._getpartialchain(name, node) | chain = self._getpartialchain(name, node) | ||||
| while chain[-1][ChainIndicies.BASENODE] != nullid: | while chain[-1][ChainIndicies.BASENODE] != sha1nodeconstants.nullid: | ||||
| x, x, deltabasename, deltabasenode, x = chain[-1] | x, x, deltabasename, deltabasenode, x = chain[-1] | ||||
| try: | try: | ||||
| morechain = self._getpartialchain(deltabasename, deltabasenode) | morechain = self._getpartialchain(deltabasename, deltabasenode) | ||||
| chain.extend(morechain) | chain.extend(morechain) | ||||
| except KeyError: | except KeyError: | ||||
| # If we allow incomplete chains, don't throw. | # If we allow incomplete chains, don't throw. | ||||
| if not self.allowincomplete: | if not self.allowincomplete: | ||||
| raise | raise | ||||
| copyrev = copyfrom = None | copyrev = copyfrom = None | ||||
| revision = shallowutil.createrevlogtext(content, copyfrom, copyrev) | revision = shallowutil.createrevlogtext(content, copyfrom, copyrev) | ||||
| return revision | return revision | ||||
| def getdelta(self, name, node): | def getdelta(self, name, node): | ||||
| # Since remotefilelog content stores only contain full texts, just | # Since remotefilelog content stores only contain full texts, just | ||||
| # return that. | # return that. | ||||
| revision = self.get(name, node) | revision = self.get(name, node) | ||||
| return revision, name, nullid, self.getmeta(name, node) | return ( | ||||
| revision, | |||||
| name, | |||||
| sha1nodeconstants.nullid, | |||||
| self.getmeta(name, node), | |||||
| ) | |||||
| def getdeltachain(self, name, node): | def getdeltachain(self, name, node): | ||||
| # Since remotefilelog content stores just contain full texts, we return | # Since remotefilelog content stores just contain full texts, we return | ||||
| # a fake delta chain that just consists of a single full text revision. | # a fake delta chain that just consists of a single full text revision. | ||||
| # The nullid in the deltabasenode slot indicates that the revision is a | # The nullid in the deltabasenode slot indicates that the revision is a | ||||
| # fulltext. | # fulltext. | ||||
| revision = self.get(name, node) | revision = self.get(name, node) | ||||
| return [(name, node, None, nullid, revision)] | return [(name, node, None, sha1nodeconstants.nullid, revision)] | ||||
| def getmeta(self, name, node): | def getmeta(self, name, node): | ||||
| self._sanitizemetacache() | self._sanitizemetacache() | ||||
| if node != self._threaddata.metacache[0]: | if node != self._threaddata.metacache[0]: | ||||
| data = self._getdata(name, node) | data = self._getdata(name, node) | ||||
| offset, size, flags = shallowutil.parsesizeflags(data) | offset, size, flags = shallowutil.parsesizeflags(data) | ||||
| self._updatemetacache(node, size, flags) | self._updatemetacache(node, size, flags) | ||||
| return self._threaddata.metacache[1] | return self._threaddata.metacache[1] | ||||
| def get(self, name, node): | def get(self, name, node): | ||||
| self._fileservice.prefetch( | self._fileservice.prefetch( | ||||
| [(name, hex(node))], force=True, fetchdata=True | [(name, hex(node))], force=True, fetchdata=True | ||||
| ) | ) | ||||
| return self._shared.get(name, node) | return self._shared.get(name, node) | ||||
| def getdelta(self, name, node): | def getdelta(self, name, node): | ||||
| revision = self.get(name, node) | revision = self.get(name, node) | ||||
| return revision, name, nullid, self._shared.getmeta(name, node) | return ( | ||||
| revision, | |||||
| name, | |||||
| sha1nodeconstants.nullid, | |||||
| self._shared.getmeta(name, node), | |||||
| ) | |||||
| def getdeltachain(self, name, node): | def getdeltachain(self, name, node): | ||||
| # Since our remote content stores just contain full texts, we return a | # Since our remote content stores just contain full texts, we return a | ||||
| # fake delta chain that just consists of a single full text revision. | # fake delta chain that just consists of a single full text revision. | ||||
| # The nullid in the deltabasenode slot indicates that the revision is a | # The nullid in the deltabasenode slot indicates that the revision is a | ||||
| # fulltext. | # fulltext. | ||||
| revision = self.get(name, node) | revision = self.get(name, node) | ||||
| return [(name, node, None, nullid, revision)] | return [(name, node, None, sha1nodeconstants.nullid, revision)] | ||||
| def getmeta(self, name, node): | def getmeta(self, name, node): | ||||
| self._fileservice.prefetch( | self._fileservice.prefetch( | ||||
| [(name, hex(node))], force=True, fetchdata=True | [(name, hex(node))], force=True, fetchdata=True | ||||
| ) | ) | ||||
| return self._shared.getmeta(name, node) | return self._shared.getmeta(name, node) | ||||
| def add(self, name, node, data): | def add(self, name, node, data): | ||||
| self._cl = revlog.revlog(self._svfs, b'00changelog.i') | self._cl = revlog.revlog(self._svfs, b'00changelog.i') | ||||
| self._repackstartlinkrev = 0 | self._repackstartlinkrev = 0 | ||||
| def get(self, name, node): | def get(self, name, node): | ||||
| return self._revlog(name).rawdata(node) | return self._revlog(name).rawdata(node) | ||||
| def getdelta(self, name, node): | def getdelta(self, name, node): | ||||
| revision = self.get(name, node) | revision = self.get(name, node) | ||||
| return revision, name, nullid, self.getmeta(name, node) | return revision, name, self._cl.nullid, self.getmeta(name, node) | ||||
| def getdeltachain(self, name, node): | def getdeltachain(self, name, node): | ||||
| revision = self.get(name, node) | revision = self.get(name, node) | ||||
| return [(name, node, None, nullid, revision)] | return [(name, node, None, self._cl.nullid, revision)] | ||||
| def getmeta(self, name, node): | def getmeta(self, name, node): | ||||
| rl = self._revlog(name) | rl = self._revlog(name) | ||||
| rev = rl.rev(node) | rev = rl.rev(node) | ||||
| return { | return { | ||||
| constants.METAKEYFLAG: rl.flags(rev), | constants.METAKEYFLAG: rl.flags(rev), | ||||
| constants.METAKEYSIZE: rl.rawsize(rev), | constants.METAKEYSIZE: rl.rawsize(rev), | ||||
| } | } | ||||
| def getancestors(self, name, node, known=None): | def getancestors(self, name, node, known=None): | ||||
| if known is None: | if known is None: | ||||
| known = set() | known = set() | ||||
| if node in known: | if node in known: | ||||
| return [] | return [] | ||||
| rl = self._revlog(name) | rl = self._revlog(name) | ||||
| ancestors = {} | ancestors = {} | ||||
| missing = {node} | missing = {node} | ||||
| for ancrev in rl.ancestors([rl.rev(node)], inclusive=True): | for ancrev in rl.ancestors([rl.rev(node)], inclusive=True): | ||||
| ancnode = rl.node(ancrev) | ancnode = rl.node(ancrev) | ||||
| missing.discard(ancnode) | missing.discard(ancnode) | ||||
| p1, p2 = rl.parents(ancnode) | p1, p2 = rl.parents(ancnode) | ||||
| if p1 != nullid and p1 not in known: | if p1 != self._cl.nullid and p1 not in known: | ||||
| missing.add(p1) | missing.add(p1) | ||||
| if p2 != nullid and p2 not in known: | if p2 != self._cl.nullid and p2 not in known: | ||||
| missing.add(p2) | missing.add(p2) | ||||
| linknode = self._cl.node(rl.linkrev(ancrev)) | linknode = self._cl.node(rl.linkrev(ancrev)) | ||||
| ancestors[rl.node(ancrev)] = (p1, p2, linknode, b'') | ancestors[rl.node(ancrev)] = (p1, p2, linknode, b'') | ||||
| if not missing: | if not missing: | ||||
| break | break | ||||
| return ancestors | return ancestors | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import struct | import struct | ||||
| import zlib | import zlib | ||||
| from mercurial.node import hex, nullid | from mercurial.node import ( | ||||
| hex, | |||||
| sha1nodeconstants, | |||||
| ) | |||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial import ( | from mercurial import ( | ||||
| pycompat, | pycompat, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| basepack, | basepack, | ||||
| constants, | constants, | ||||
| def createindex(self, nodelocations, indexoffset): | def createindex(self, nodelocations, indexoffset): | ||||
| entries = sorted( | entries = sorted( | ||||
| (n, db, o, s) for n, (db, o, s) in pycompat.iteritems(self.entries) | (n, db, o, s) for n, (db, o, s) in pycompat.iteritems(self.entries) | ||||
| ) | ) | ||||
| rawindex = b'' | rawindex = b'' | ||||
| fmt = self.INDEXFORMAT | fmt = self.INDEXFORMAT | ||||
| for node, deltabase, offset, size in entries: | for node, deltabase, offset, size in entries: | ||||
| if deltabase == nullid: | if deltabase == sha1nodeconstants.nullid: | ||||
| deltabaselocation = FULLTEXTINDEXMARK | deltabaselocation = FULLTEXTINDEXMARK | ||||
| else: | else: | ||||
| # Instead of storing the deltabase node in the index, let's | # Instead of storing the deltabase node in the index, let's | ||||
| # store a pointer directly to the index entry for the deltabase. | # store a pointer directly to the index entry for the deltabase. | ||||
| deltabaselocation = nodelocations.get( | deltabaselocation = nodelocations.get( | ||||
| deltabase, NOBASEINDEXMARK | deltabase, NOBASEINDEXMARK | ||||
| ) | ) | ||||
| entry = struct.pack(fmt, node, deltabaselocation, offset, size) | entry = struct.pack(fmt, node, deltabaselocation, offset, size) | ||||
| rawindex += entry | rawindex += entry | ||||
| return rawindex | return rawindex | ||||
| # debugcommands.py - debug logic for remotefilelog | # debugcommands.py - debug logic for remotefilelog | ||||
| # | # | ||||
| # Copyright 2013 Facebook, Inc. | # Copyright 2013 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import os | import os | ||||
| import zlib | import zlib | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | sha1nodeconstants, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.pycompat import open | from mercurial.pycompat import open | ||||
| from mercurial import ( | from mercurial import ( | ||||
| error, | error, | ||||
| filelog, | filelog, | ||||
| lock as lockmod, | lock as lockmod, | ||||
| queue = [firstnode] | queue = [firstnode] | ||||
| while queue: | while queue: | ||||
| node = queue.pop(0) | node = queue.pop(0) | ||||
| p1, p2, linknode, copyfrom = mapping[node] | p1, p2, linknode, copyfrom = mapping[node] | ||||
| ui.status( | ui.status( | ||||
| _(b"%s => %s %s %s %s\n") | _(b"%s => %s %s %s %s\n") | ||||
| % (short(node), short(p1), short(p2), short(linknode), copyfrom) | % (short(node), short(p1), short(p2), short(linknode), copyfrom) | ||||
| ) | ) | ||||
| if p1 != nullid: | if p1 != sha1nodeconstants.nullid: | ||||
| queue.append(p1) | queue.append(p1) | ||||
| if p2 != nullid: | if p2 != sha1nodeconstants.nullid: | ||||
| queue.append(p2) | queue.append(p2) | ||||
| def buildtemprevlog(repo, file): | def buildtemprevlog(repo, file): | ||||
| # get filename key | # get filename key | ||||
| filekey = hex(hashutil.sha1(file).digest()) | filekey = hex(hashutil.sha1(file).digest()) | ||||
| filedir = os.path.join(repo.path, b'store/data', filekey) | filedir = os.path.join(repo.path, b'store/data', filekey) | ||||
| if generaldelta: | if generaldelta: | ||||
| base = r.deltaparent(i) | base = r.deltaparent(i) | ||||
| else: | else: | ||||
| base = r.chainbase(i) | base = r.chainbase(i) | ||||
| if format == 0: | if format == 0: | ||||
| try: | try: | ||||
| pp = r.parents(node) | pp = r.parents(node) | ||||
| except Exception: | except Exception: | ||||
| pp = [nullid, nullid] | pp = [repo.nullid, repo.nullid] | ||||
| ui.write( | ui.write( | ||||
| b"% 6d % 9d % 7d % 6d % 7d %s %s %s\n" | b"% 6d % 9d % 7d % 6d % 7d %s %s %s\n" | ||||
| % ( | % ( | ||||
| i, | i, | ||||
| r.start(i), | r.start(i), | ||||
| r.length(i), | r.length(i), | ||||
| base, | base, | ||||
| r.linkrev(i), | r.linkrev(i), | ||||
| r = buildtemprevlog(repo, os.path.basename(file_)[:-2]) | r = buildtemprevlog(repo, os.path.basename(file_)[:-2]) | ||||
| ui.writenoi18n(b"digraph G {\n") | ui.writenoi18n(b"digraph G {\n") | ||||
| for i in r: | for i in r: | ||||
| node = r.node(i) | node = r.node(i) | ||||
| pp = r.parents(node) | pp = r.parents(node) | ||||
| ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i)) | ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i)) | ||||
| if pp[1] != nullid: | if pp[1] != repo.nullid: | ||||
| ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i)) | ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i)) | ||||
| ui.write(b"}\n") | ui.write(b"}\n") | ||||
| def verifyremotefilelog(ui, path, **opts): | def verifyremotefilelog(ui, path, **opts): | ||||
| decompress = opts.get('decompress') | decompress = opts.get('decompress') | ||||
| for root, dirs, files in os.walk(path): | for root, dirs, files in os.walk(path): | ||||
| for file in files: | for file in files: | ||||
| if file == b"repos": | if file == b"repos": | ||||
| continue | continue | ||||
| filepath = os.path.join(root, file) | filepath = os.path.join(root, file) | ||||
| size, firstnode, mapping = parsefileblob(filepath, decompress) | size, firstnode, mapping = parsefileblob(filepath, decompress) | ||||
| for p1, p2, linknode, copyfrom in pycompat.itervalues(mapping): | for p1, p2, linknode, copyfrom in pycompat.itervalues(mapping): | ||||
| if linknode == nullid: | if linknode == sha1nodeconstants.nullid: | ||||
| actualpath = os.path.relpath(root, path) | actualpath = os.path.relpath(root, path) | ||||
| key = fileserverclient.getcachekey( | key = fileserverclient.getcachekey( | ||||
| b"reponame", actualpath, file | b"reponame", actualpath, file | ||||
| ) | ) | ||||
| ui.status( | ui.status( | ||||
| b"%s %s\n" % (key, os.path.relpath(filepath, path)) | b"%s %s\n" % (key, os.path.relpath(filepath, path)) | ||||
| ) | ) | ||||
| - There must be no cycles | - There must be no cycles | ||||
| """ | """ | ||||
| failures = 0 | failures = 0 | ||||
| for node in nodes: | for node in nodes: | ||||
| seen = set() | seen = set() | ||||
| current = node | current = node | ||||
| deltabase = bases[current] | deltabase = bases[current] | ||||
| while deltabase != nullid: | while deltabase != sha1nodeconstants.nullid: | ||||
| if deltabase not in nodes: | if deltabase not in nodes: | ||||
| ui.warn( | ui.warn( | ||||
| ( | ( | ||||
| b"Bad entry: %s has an unknown deltabase (%s)\n" | b"Bad entry: %s has an unknown deltabase (%s)\n" | ||||
| % (short(node), short(deltabase)) | % (short(node), short(deltabase)) | ||||
| ) | ) | ||||
| ) | ) | ||||
| failures += 1 | failures += 1 | ||||
| failures += 1 | failures += 1 | ||||
| break | break | ||||
| current = deltabase | current = deltabase | ||||
| seen.add(current) | seen.add(current) | ||||
| deltabase = bases[current] | deltabase = bases[current] | ||||
| # Since ``node`` begins a valid chain, reset/memoize its base to nullid | # Since ``node`` begins a valid chain, reset/memoize its base to nullid | ||||
| # so we don't traverse it again. | # so we don't traverse it again. | ||||
| bases[node] = nullid | bases[node] = sha1nodeconstants.nullid | ||||
| return failures | return failures | ||||
| def dumpdeltachain(ui, deltachain, **opts): | def dumpdeltachain(ui, deltachain, **opts): | ||||
| hashformatter = hex | hashformatter = hex | ||||
| hashlen = 40 | hashlen = 40 | ||||
| lastfilename = None | lastfilename = None | ||||
| # fileserverclient.py - client for communicating with the cache process | # fileserverclient.py - client for communicating with the cache process | ||||
| # | # | ||||
| # Copyright 2013 Facebook, Inc. | # Copyright 2013 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import io | import io | ||||
| import os | import os | ||||
| import threading | import threading | ||||
| import time | import time | ||||
| import zlib | import zlib | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import bin, hex, nullid | from mercurial.node import bin, hex | ||||
| from mercurial import ( | from mercurial import ( | ||||
| error, | error, | ||||
| pycompat, | pycompat, | ||||
| revlog, | revlog, | ||||
| sshpeer, | sshpeer, | ||||
| util, | util, | ||||
| wireprotov1peer, | wireprotov1peer, | ||||
| ) | ) | ||||
| missingids = set() | missingids = set() | ||||
| if fetchdata: | if fetchdata: | ||||
| missingids.update(datastore.getmissing(idstocheck)) | missingids.update(datastore.getmissing(idstocheck)) | ||||
| if fetchhistory: | if fetchhistory: | ||||
| missingids.update(historystore.getmissing(idstocheck)) | missingids.update(historystore.getmissing(idstocheck)) | ||||
| # partition missing nodes into nullid and not-nullid so we can | # partition missing nodes into nullid and not-nullid so we can | ||||
| # warn about this filtering potentially shadowing bugs. | # warn about this filtering potentially shadowing bugs. | ||||
| nullids = len([None for unused, id in missingids if id == nullid]) | nullids = len( | ||||
| [None for unused, id in missingids if id == self.repo.nullid] | |||||
| ) | |||||
| if nullids: | if nullids: | ||||
| missingids = [(f, id) for f, id in missingids if id != nullid] | missingids = [ | ||||
| (f, id) for f, id in missingids if id != self.repo.nullid | |||||
| ] | |||||
| repo.ui.develwarn( | repo.ui.develwarn( | ||||
| ( | ( | ||||
| b'remotefilelog not fetching %d null revs' | b'remotefilelog not fetching %d null revs' | ||||
| b' - this is likely hiding bugs' % nullids | b' - this is likely hiding bugs' % nullids | ||||
| ), | ), | ||||
| config=b'remotefilelog-ext', | config=b'remotefilelog-ext', | ||||
| ) | ) | ||||
| if missingids: | if missingids: | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import struct | import struct | ||||
| from mercurial.node import hex, nullid | from mercurial.node import ( | ||||
| hex, | |||||
| sha1nodeconstants, | |||||
| ) | |||||
| from mercurial import ( | from mercurial import ( | ||||
| pycompat, | pycompat, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from mercurial.utils import hashutil | from mercurial.utils import hashutil | ||||
| from . import ( | from . import ( | ||||
| basepack, | basepack, | ||||
| constants, | constants, | ||||
| if copyfrom: | if copyfrom: | ||||
| o += len(copyfrom) | o += len(copyfrom) | ||||
| ancnode = entry[ANC_NODE] | ancnode = entry[ANC_NODE] | ||||
| if ancnode in pending: | if ancnode in pending: | ||||
| pending.remove(ancnode) | pending.remove(ancnode) | ||||
| p1node = entry[ANC_P1NODE] | p1node = entry[ANC_P1NODE] | ||||
| p2node = entry[ANC_P2NODE] | p2node = entry[ANC_P2NODE] | ||||
| if p1node != nullid and p1node not in known: | if p1node != sha1nodeconstants.nullid and p1node not in known: | ||||
| pending.add(p1node) | pending.add(p1node) | ||||
| if p2node != nullid and p2node not in known: | if p2node != sha1nodeconstants.nullid and p2node not in known: | ||||
| pending.add(p2node) | pending.add(p2node) | ||||
| yield (ancnode, p1node, p2node, entry[ANC_LINKNODE], copyfrom) | yield (ancnode, p1node, p2node, entry[ANC_LINKNODE], copyfrom) | ||||
| def _readentry(self, offset): | def _readentry(self, offset): | ||||
| data = self._data | data = self._data | ||||
| entry = struct.unpack( | entry = struct.unpack( | ||||
| PACKFORMAT, data[offset : offset + PACKENTRYLENGTH] | PACKFORMAT, data[offset : offset + PACKENTRYLENGTH] | ||||
| sectionstart = self.packfp.tell() | sectionstart = self.packfp.tell() | ||||
| # Write the file section content | # Write the file section content | ||||
| entrymap = {e[0]: e for e in entries} | entrymap = {e[0]: e for e in entries} | ||||
| def parentfunc(node): | def parentfunc(node): | ||||
| x, p1, p2, x, x, x = entrymap[node] | x, p1, p2, x, x, x = entrymap[node] | ||||
| parents = [] | parents = [] | ||||
| if p1 != nullid: | if p1 != sha1nodeconstants.nullid: | ||||
| parents.append(p1) | parents.append(p1) | ||||
| if p2 != nullid: | if p2 != sha1nodeconstants.nullid: | ||||
| parents.append(p2) | parents.append(p2) | ||||
| return parents | return parents | ||||
| sortednodes = list( | sortednodes = list( | ||||
| reversed( | reversed( | ||||
| shallowutil.sortnodes((e[0] for e in entries), parentfunc) | shallowutil.sortnodes((e[0] for e in entries), parentfunc) | ||||
| ) | ) | ||||
| ) | ) | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from mercurial.node import hex, nullid | from mercurial.node import ( | ||||
| hex, | |||||
| sha1nodeconstants, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| basestore, | basestore, | ||||
| shallowutil, | shallowutil, | ||||
| ) | ) | ||||
| class unionmetadatastore(basestore.baseunionstore): | class unionmetadatastore(basestore.baseunionstore): | ||||
| def __init__(self, *args, **kwargs): | def __init__(self, *args, **kwargs): | ||||
| if (name, node) in seen: | if (name, node) in seen: | ||||
| continue | continue | ||||
| seen.add((name, node)) | seen.add((name, node)) | ||||
| value = ancestors.get(node) | value = ancestors.get(node) | ||||
| if not value: | if not value: | ||||
| missing.append((name, node)) | missing.append((name, node)) | ||||
| continue | continue | ||||
| p1, p2, linknode, copyfrom = value | p1, p2, linknode, copyfrom = value | ||||
| if p1 != nullid and p1 not in known: | if p1 != sha1nodeconstants.nullid and p1 not in known: | ||||
| queue.append((copyfrom or curname, p1)) | queue.append((copyfrom or curname, p1)) | ||||
| if p2 != nullid and p2 not in known: | if p2 != sha1nodeconstants.nullid and p2 not in known: | ||||
| queue.append((curname, p2)) | queue.append((curname, p2)) | ||||
| return missing | return missing | ||||
| missing = [(name, node)] | missing = [(name, node)] | ||||
| while missing: | while missing: | ||||
| curname, curnode = missing.pop() | curname, curnode = missing.pop() | ||||
| try: | try: | ||||
| ancestors.update( | ancestors.update( | ||||
| # remotefilectx.py - filectx/workingfilectx implementations for remotefilelog | # remotefilectx.py - filectx/workingfilectx implementations for remotefilelog | ||||
| # | # | ||||
| # Copyright 2013 Facebook, Inc. | # Copyright 2013 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import time | import time | ||||
| from mercurial.node import bin, hex, nullid, nullrev | from mercurial.node import bin, hex, nullrev | ||||
| from mercurial import ( | from mercurial import ( | ||||
| ancestor, | ancestor, | ||||
| context, | context, | ||||
| error, | error, | ||||
| phases, | phases, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from . import shallowutil | from . import shallowutil | ||||
| path, | path, | ||||
| changeid=None, | changeid=None, | ||||
| fileid=None, | fileid=None, | ||||
| filelog=None, | filelog=None, | ||||
| changectx=None, | changectx=None, | ||||
| ancestormap=None, | ancestormap=None, | ||||
| ): | ): | ||||
| if fileid == nullrev: | if fileid == nullrev: | ||||
| fileid = nullid | fileid = repo.nullid | ||||
| if fileid and len(fileid) == 40: | if fileid and len(fileid) == 40: | ||||
| fileid = bin(fileid) | fileid = bin(fileid) | ||||
| super(remotefilectx, self).__init__( | super(remotefilectx, self).__init__( | ||||
| repo, path, changeid, fileid, filelog, changectx | repo, path, changeid, fileid, filelog, changectx | ||||
| ) | ) | ||||
| self._ancestormap = ancestormap | self._ancestormap = ancestormap | ||||
| def size(self): | def size(self): | ||||
| changeid=changeid, | changeid=changeid, | ||||
| ) | ) | ||||
| def linkrev(self): | def linkrev(self): | ||||
| return self._linkrev | return self._linkrev | ||||
| @propertycache | @propertycache | ||||
| def _linkrev(self): | def _linkrev(self): | ||||
| if self._filenode == nullid: | if self._filenode == self._repo.nullid: | ||||
| return nullrev | return nullrev | ||||
| ancestormap = self.ancestormap() | ancestormap = self.ancestormap() | ||||
| p1, p2, linknode, copyfrom = ancestormap[self._filenode] | p1, p2, linknode, copyfrom = ancestormap[self._filenode] | ||||
| rev = self._repo.changelog.index.get_rev(linknode) | rev = self._repo.changelog.index.get_rev(linknode) | ||||
| if rev is not None: | if rev is not None: | ||||
| return rev | return rev | ||||
| return self._ancestormap | return self._ancestormap | ||||
| def parents(self): | def parents(self): | ||||
| repo = self._repo | repo = self._repo | ||||
| ancestormap = self.ancestormap() | ancestormap = self.ancestormap() | ||||
| p1, p2, linknode, copyfrom = ancestormap[self._filenode] | p1, p2, linknode, copyfrom = ancestormap[self._filenode] | ||||
| results = [] | results = [] | ||||
| if p1 != nullid: | if p1 != repo.nullid: | ||||
| path = copyfrom or self._path | path = copyfrom or self._path | ||||
| flog = repo.file(path) | flog = repo.file(path) | ||||
| p1ctx = remotefilectx( | p1ctx = remotefilectx( | ||||
| repo, path, fileid=p1, filelog=flog, ancestormap=ancestormap | repo, path, fileid=p1, filelog=flog, ancestormap=ancestormap | ||||
| ) | ) | ||||
| p1ctx._descendantrev = self.rev() | p1ctx._descendantrev = self.rev() | ||||
| results.append(p1ctx) | results.append(p1ctx) | ||||
| if p2 != nullid: | if p2 != repo.nullid: | ||||
| path = self._path | path = self._path | ||||
| flog = repo.file(path) | flog = repo.file(path) | ||||
| p2ctx = remotefilectx( | p2ctx = remotefilectx( | ||||
| repo, path, fileid=p2, filelog=flog, ancestormap=ancestormap | repo, path, fileid=p2, filelog=flog, ancestormap=ancestormap | ||||
| ) | ) | ||||
| p2ctx._descendantrev = self.rev() | p2ctx._descendantrev = self.rev() | ||||
| results.append(p2ctx) | results.append(p2ctx) | ||||
| if not self._ancestormap: | if not self._ancestormap: | ||||
| path = self._path | path = self._path | ||||
| pcl = self._changectx._parents | pcl = self._changectx._parents | ||||
| renamed = self.renamed() | renamed = self.renamed() | ||||
| if renamed: | if renamed: | ||||
| p1 = renamed | p1 = renamed | ||||
| else: | else: | ||||
| p1 = (path, pcl[0]._manifest.get(path, nullid)) | p1 = (path, pcl[0]._manifest.get(path, self._repo.nullid)) | ||||
| p2 = (path, nullid) | p2 = (path, self._repo.nullid) | ||||
| if len(pcl) > 1: | if len(pcl) > 1: | ||||
| p2 = (path, pcl[1]._manifest.get(path, nullid)) | p2 = (path, pcl[1]._manifest.get(path, self._repo.nullid)) | ||||
| m = {} | m = {} | ||||
| if p1[1] != nullid: | if p1[1] != self._repo.nullid: | ||||
| p1ctx = self._repo.filectx(p1[0], fileid=p1[1]) | p1ctx = self._repo.filectx(p1[0], fileid=p1[1]) | ||||
| m.update(p1ctx.filelog().ancestormap(p1[1])) | m.update(p1ctx.filelog().ancestormap(p1[1])) | ||||
| if p2[1] != nullid: | if p2[1] != self._repo.nullid: | ||||
| p2ctx = self._repo.filectx(p2[0], fileid=p2[1]) | p2ctx = self._repo.filectx(p2[0], fileid=p2[1]) | ||||
| m.update(p2ctx.filelog().ancestormap(p2[1])) | m.update(p2ctx.filelog().ancestormap(p2[1])) | ||||
| copyfrom = b'' | copyfrom = b'' | ||||
| if renamed: | if renamed: | ||||
| copyfrom = renamed[0] | copyfrom = renamed[0] | ||||
| m[None] = (p1[1], p2[1], nullid, copyfrom) | m[None] = (p1[1], p2[1], self._repo.nullid, copyfrom) | ||||
| self._ancestormap = m | self._ancestormap = m | ||||
| return self._ancestormap | return self._ancestormap | ||||
| # remotefilelog.py - filelog implementation where filelog history is stored | # remotefilelog.py - filelog implementation where filelog history is stored | ||||
| # remotely | # remotely | ||||
| # | # | ||||
| # Copyright 2013 Facebook, Inc. | # Copyright 2013 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import os | import os | ||||
| from mercurial.node import ( | from mercurial.node import bin | ||||
| bin, | |||||
| nullid, | |||||
| wdirfilenodeids, | |||||
| wdirid, | |||||
| ) | |||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial import ( | from mercurial import ( | ||||
| ancestor, | ancestor, | ||||
| error, | error, | ||||
| mdiff, | mdiff, | ||||
| pycompat, | pycompat, | ||||
| revlog, | revlog, | ||||
| util, | util, | ||||
| realp1 = bin(meta[b'copyrev']) | realp1 = bin(meta[b'copyrev']) | ||||
| data += b"%s%s%s%s%s\0" % (node, realp1, p2, linknode, copyfrom) | data += b"%s%s%s%s%s\0" % (node, realp1, p2, linknode, copyfrom) | ||||
| visited = set() | visited = set() | ||||
| pancestors = {} | pancestors = {} | ||||
| queue = [] | queue = [] | ||||
| if realp1 != nullid: | if realp1 != self.repo.nullid: | ||||
| p1flog = self | p1flog = self | ||||
| if copyfrom: | if copyfrom: | ||||
| p1flog = remotefilelog(self.opener, copyfrom, self.repo) | p1flog = remotefilelog(self.opener, copyfrom, self.repo) | ||||
| pancestors.update(p1flog.ancestormap(realp1)) | pancestors.update(p1flog.ancestormap(realp1)) | ||||
| queue.append(realp1) | queue.append(realp1) | ||||
| visited.add(realp1) | visited.add(realp1) | ||||
| if p2 != nullid: | if p2 != self.repo.nullid: | ||||
| pancestors.update(self.ancestormap(p2)) | pancestors.update(self.ancestormap(p2)) | ||||
| queue.append(p2) | queue.append(p2) | ||||
| visited.add(p2) | visited.add(p2) | ||||
| ancestortext = b"" | ancestortext = b"" | ||||
| # add the ancestors in topological order | # add the ancestors in topological order | ||||
| while queue: | while queue: | ||||
| c = queue.pop(0) | c = queue.pop(0) | ||||
| pa1, pa2, ancestorlinknode, pacopyfrom = pancestors[c] | pa1, pa2, ancestorlinknode, pacopyfrom = pancestors[c] | ||||
| pacopyfrom = pacopyfrom or b'' | pacopyfrom = pacopyfrom or b'' | ||||
| ancestortext += b"%s%s%s%s%s\0" % ( | ancestortext += b"%s%s%s%s%s\0" % ( | ||||
| c, | c, | ||||
| pa1, | pa1, | ||||
| pa2, | pa2, | ||||
| ancestorlinknode, | ancestorlinknode, | ||||
| pacopyfrom, | pacopyfrom, | ||||
| ) | ) | ||||
| if pa1 != nullid and pa1 not in visited: | if pa1 != self.repo.nullid and pa1 not in visited: | ||||
| queue.append(pa1) | queue.append(pa1) | ||||
| visited.add(pa1) | visited.add(pa1) | ||||
| if pa2 != nullid and pa2 not in visited: | if pa2 != self.repo.nullid and pa2 not in visited: | ||||
| queue.append(pa2) | queue.append(pa2) | ||||
| visited.add(pa2) | visited.add(pa2) | ||||
| data += ancestortext | data += ancestortext | ||||
| return data | return data | ||||
| def addrevision( | def addrevision( | ||||
| rawsize = size | rawsize = size | ||||
| def cmp(self, node, text): | def cmp(self, node, text): | ||||
| """compare text with a given file revision | """compare text with a given file revision | ||||
| returns True if text is different than what is stored. | returns True if text is different than what is stored. | ||||
| """ | """ | ||||
| if node == nullid: | if node == self.repo.nullid: | ||||
| return True | return True | ||||
| nodetext = self.read(node) | nodetext = self.read(node) | ||||
| return nodetext != text | return nodetext != text | ||||
| def __nonzero__(self): | def __nonzero__(self): | ||||
| return True | return True | ||||
| if isinstance(node, int): | if isinstance(node, int): | ||||
| raise error.ProgrammingError( | raise error.ProgrammingError( | ||||
| b'remotefilelog does not accept integer rev for flags' | b'remotefilelog does not accept integer rev for flags' | ||||
| ) | ) | ||||
| store = self.repo.contentstore | store = self.repo.contentstore | ||||
| return store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0) | return store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0) | ||||
| def parents(self, node): | def parents(self, node): | ||||
| if node == nullid: | if node == self.repo.nullid: | ||||
| return nullid, nullid | return self.repo.nullid, self.repo.nullid | ||||
| ancestormap = self.repo.metadatastore.getancestors(self.filename, node) | ancestormap = self.repo.metadatastore.getancestors(self.filename, node) | ||||
| p1, p2, linknode, copyfrom = ancestormap[node] | p1, p2, linknode, copyfrom = ancestormap[node] | ||||
| if copyfrom: | if copyfrom: | ||||
| p1 = nullid | p1 = self.repo.nullid | ||||
| return p1, p2 | return p1, p2 | ||||
| def parentrevs(self, rev): | def parentrevs(self, rev): | ||||
| # TODO(augie): this is a node and should be a rev, but for now | # TODO(augie): this is a node and should be a rev, but for now | ||||
| # nothing in core seems to actually break. | # nothing in core seems to actually break. | ||||
| return self.parents(rev) | return self.parents(rev) | ||||
| del nodesorder, revisiondata, assumehaveparentrevisions, deltaprevious | del nodesorder, revisiondata, assumehaveparentrevisions, deltaprevious | ||||
| del deltamode | del deltamode | ||||
| prevnode = None | prevnode = None | ||||
| for node in nodes: | for node in nodes: | ||||
| p1, p2 = self.parents(node) | p1, p2 = self.parents(node) | ||||
| if prevnode is None: | if prevnode is None: | ||||
| basenode = prevnode = p1 | basenode = prevnode = p1 | ||||
| if basenode == node: | if basenode == node: | ||||
| basenode = nullid | basenode = self.repo.nullid | ||||
| if basenode != nullid: | if basenode != self.repo.nullid: | ||||
| revision = None | revision = None | ||||
| delta = self.revdiff(basenode, node) | delta = self.revdiff(basenode, node) | ||||
| else: | else: | ||||
| revision = self.rawdata(node) | revision = self.rawdata(node) | ||||
| delta = None | delta = None | ||||
| yield revlog.revlogrevisiondelta( | yield revlog.revlogrevisiondelta( | ||||
| node=node, | node=node, | ||||
| p1node=p1, | p1node=p1, | ||||
| return flagutil.processflagswrite(self, text, flags) | return flagutil.processflagswrite(self, text, flags) | ||||
| def revision(self, node, raw=False): | def revision(self, node, raw=False): | ||||
| """returns the revlog contents at this node. | """returns the revlog contents at this node. | ||||
| this includes the meta data traditionally included in file revlogs. | this includes the meta data traditionally included in file revlogs. | ||||
| this is generally only used for bundling and communicating with vanilla | this is generally only used for bundling and communicating with vanilla | ||||
| hg clients. | hg clients. | ||||
| """ | """ | ||||
| if node == nullid: | if node == self.repo.nullid: | ||||
| return b"" | return b"" | ||||
| if len(node) != 20: | if len(node) != 20: | ||||
| raise error.LookupError( | raise error.LookupError( | ||||
| node, self.filename, _(b'invalid revision input') | node, self.filename, _(b'invalid revision input') | ||||
| ) | ) | ||||
| if node == wdirid or node in wdirfilenodeids: | if ( | ||||
| node == self.repo.nodeconstants.wdirid | |||||
| or node in self.repo.nodeconstants.wdirfilenodeids | |||||
| ): | |||||
| raise error.WdirUnsupported | raise error.WdirUnsupported | ||||
| store = self.repo.contentstore | store = self.repo.contentstore | ||||
| rawtext = store.get(self.filename, node) | rawtext = store.get(self.filename, node) | ||||
| if raw: | if raw: | ||||
| return rawtext | return rawtext | ||||
| flags = store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0) | flags = store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0) | ||||
| if flags == 0: | if flags == 0: | ||||
| pass | pass | ||||
| raise error.LookupError(id, self.filename, _(b'no node')) | raise error.LookupError(id, self.filename, _(b'no node')) | ||||
| def ancestormap(self, node): | def ancestormap(self, node): | ||||
| return self.repo.metadatastore.getancestors(self.filename, node) | return self.repo.metadatastore.getancestors(self.filename, node) | ||||
| def ancestor(self, a, b): | def ancestor(self, a, b): | ||||
| if a == nullid or b == nullid: | if a == self.repo.nullid or b == self.repo.nullid: | ||||
| return nullid | return self.repo.nullid | ||||
| revmap, parentfunc = self._buildrevgraph(a, b) | revmap, parentfunc = self._buildrevgraph(a, b) | ||||
| nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)} | nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)} | ||||
| ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b]) | ancs = ancestor.ancestors(parentfunc, revmap[a], revmap[b]) | ||||
| if ancs: | if ancs: | ||||
| # choose a consistent winner when there's a tie | # choose a consistent winner when there's a tie | ||||
| return min(map(nodemap.__getitem__, ancs)) | return min(map(nodemap.__getitem__, ancs)) | ||||
| return nullid | return self.repo.nullid | ||||
| def commonancestorsheads(self, a, b): | def commonancestorsheads(self, a, b): | ||||
| """calculate all the heads of the common ancestors of nodes a and b""" | """calculate all the heads of the common ancestors of nodes a and b""" | ||||
| if a == nullid or b == nullid: | if a == self.repo.nullid or b == self.repo.nullid: | ||||
| return nullid | return self.repo.nullid | ||||
| revmap, parentfunc = self._buildrevgraph(a, b) | revmap, parentfunc = self._buildrevgraph(a, b) | ||||
| nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)} | nodemap = {v: k for (k, v) in pycompat.iteritems(revmap)} | ||||
| ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b]) | ancs = ancestor.commonancestorsheads(parentfunc, revmap[a], revmap[b]) | ||||
| return map(nodemap.__getitem__, ancs) | return map(nodemap.__getitem__, ancs) | ||||
| def _buildrevgraph(self, a, b): | def _buildrevgraph(self, a, b): | ||||
| """Builds a numeric revision graph for the given two nodes. | """Builds a numeric revision graph for the given two nodes. | ||||
| Returns a node->rev map and a rev->[revs] parent function. | Returns a node->rev map and a rev->[revs] parent function. | ||||
| """ | """ | ||||
| amap = self.ancestormap(a) | amap = self.ancestormap(a) | ||||
| bmap = self.ancestormap(b) | bmap = self.ancestormap(b) | ||||
| # Union the two maps | # Union the two maps | ||||
| parentsmap = collections.defaultdict(list) | parentsmap = collections.defaultdict(list) | ||||
| allparents = set() | allparents = set() | ||||
| for mapping in (amap, bmap): | for mapping in (amap, bmap): | ||||
| for node, pdata in pycompat.iteritems(mapping): | for node, pdata in pycompat.iteritems(mapping): | ||||
| parents = parentsmap[node] | parents = parentsmap[node] | ||||
| p1, p2, linknode, copyfrom = pdata | p1, p2, linknode, copyfrom = pdata | ||||
| # Don't follow renames (copyfrom). | # Don't follow renames (copyfrom). | ||||
| # remotefilectx.ancestor does that. | # remotefilectx.ancestor does that. | ||||
| if p1 != nullid and not copyfrom: | if p1 != self.repo.nullid and not copyfrom: | ||||
| parents.append(p1) | parents.append(p1) | ||||
| allparents.add(p1) | allparents.add(p1) | ||||
| if p2 != nullid: | if p2 != self.repo.nullid: | ||||
| parents.append(p2) | parents.append(p2) | ||||
| allparents.add(p2) | allparents.add(p2) | ||||
| # Breadth first traversal to build linkrev graph | # Breadth first traversal to build linkrev graph | ||||
| parentrevs = collections.defaultdict(list) | parentrevs = collections.defaultdict(list) | ||||
| revmap = {} | revmap = {} | ||||
| queue = collections.deque( | queue = collections.deque( | ||||
| ((None, n) for n in parentsmap if n not in allparents) | ((None, n) for n in parentsmap if n not in allparents) | ||||
| # remotefilelogserver.py - server logic for a remotefilelog server | # remotefilelogserver.py - server logic for a remotefilelog server | ||||
| # | # | ||||
| # Copyright 2013 Facebook, Inc. | # Copyright 2013 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import errno | import errno | ||||
| import os | import os | ||||
| import stat | import stat | ||||
| import time | import time | ||||
| import zlib | import zlib | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import bin, hex, nullid | from mercurial.node import bin, hex | ||||
| from mercurial.pycompat import open | from mercurial.pycompat import open | ||||
| from mercurial import ( | from mercurial import ( | ||||
| changegroup, | changegroup, | ||||
| changelog, | changelog, | ||||
| context, | context, | ||||
| error, | error, | ||||
| extensions, | extensions, | ||||
| match, | match, | ||||
| extensions.wrapfunction(wireprotoserver, b'iscmd', _iscmd) | extensions.wrapfunction(wireprotoserver, b'iscmd', _iscmd) | ||||
| def _loadfileblob(repo, cachepath, path, node): | def _loadfileblob(repo, cachepath, path, node): | ||||
| filecachepath = os.path.join(cachepath, path, hex(node)) | filecachepath = os.path.join(cachepath, path, hex(node)) | ||||
| if not os.path.exists(filecachepath) or os.path.getsize(filecachepath) == 0: | if not os.path.exists(filecachepath) or os.path.getsize(filecachepath) == 0: | ||||
| filectx = repo.filectx(path, fileid=node) | filectx = repo.filectx(path, fileid=node) | ||||
| if filectx.node() == nullid: | if filectx.node() == repo.nullid: | ||||
| repo.changelog = changelog.changelog(repo.svfs) | repo.changelog = changelog.changelog(repo.svfs) | ||||
| filectx = repo.filectx(path, fileid=node) | filectx = repo.filectx(path, fileid=node) | ||||
| text = createfileblob(filectx) | text = createfileblob(filectx) | ||||
| # TODO configurable compression engines | # TODO configurable compression engines | ||||
| text = zlib.compress(text) | text = zlib.compress(text) | ||||
| # everything should be user & group read/writable | # everything should be user & group read/writable | ||||
| text = f.read() | text = f.read() | ||||
| return text | return text | ||||
| def getflogheads(repo, proto, path): | def getflogheads(repo, proto, path): | ||||
| """A server api for requesting a filelog's heads""" | """A server api for requesting a filelog's heads""" | ||||
| flog = repo.file(path) | flog = repo.file(path) | ||||
| heads = flog.heads() | heads = flog.heads() | ||||
| return b'\n'.join((hex(head) for head in heads if head != nullid)) | return b'\n'.join((hex(head) for head in heads if head != repo.nullid)) | ||||
| def getfile(repo, proto, file, node): | def getfile(repo, proto, file, node): | ||||
| """A server api for requesting a particular version of a file. Can be used | """A server api for requesting a particular version of a file. Can be used | ||||
| in batches to request many files at once. The return protocol is: | in batches to request many files at once. The return protocol is: | ||||
| <errorcode>\0<data/errormsg> where <errorcode> is 0 for success or | <errorcode>\0<data/errormsg> where <errorcode> is 0 for success or | ||||
| non-zero for an error. | non-zero for an error. | ||||
| data is a compressed blob with revlog flag and ancestors information. See | data is a compressed blob with revlog flag and ancestors information. See | ||||
| createfileblob for its content. | createfileblob for its content. | ||||
| """ | """ | ||||
| if shallowutil.isenabled(repo): | if shallowutil.isenabled(repo): | ||||
| return b'1\0' + _(b'cannot fetch remote files from shallow repo') | return b'1\0' + _(b'cannot fetch remote files from shallow repo') | ||||
| cachepath = repo.ui.config(b"remotefilelog", b"servercachepath") | cachepath = repo.ui.config(b"remotefilelog", b"servercachepath") | ||||
| if not cachepath: | if not cachepath: | ||||
| cachepath = os.path.join(repo.path, b"remotefilelogcache") | cachepath = os.path.join(repo.path, b"remotefilelogcache") | ||||
| node = bin(node.strip()) | node = bin(node.strip()) | ||||
| if node == nullid: | if node == repo.nullid: | ||||
| return b'0\0' | return b'0\0' | ||||
| return b'0\0' + _loadfileblob(repo, cachepath, file, node) | return b'0\0' + _loadfileblob(repo, cachepath, file, node) | ||||
| def getfiles(repo, proto): | def getfiles(repo, proto): | ||||
| """A server api for requesting particular versions of particular files.""" | """A server api for requesting particular versions of particular files.""" | ||||
| if shallowutil.isenabled(repo): | if shallowutil.isenabled(repo): | ||||
| raise error.Abort(_(b'cannot fetch remote files from shallow repo')) | raise error.Abort(_(b'cannot fetch remote files from shallow repo')) | ||||
| if not isinstance(proto, _sshv1server): | if not isinstance(proto, _sshv1server): | ||||
| raise error.Abort(_(b'cannot fetch remote files over non-ssh protocol')) | raise error.Abort(_(b'cannot fetch remote files over non-ssh protocol')) | ||||
| def streamer(): | def streamer(): | ||||
| fin = proto._fin | fin = proto._fin | ||||
| cachepath = repo.ui.config(b"remotefilelog", b"servercachepath") | cachepath = repo.ui.config(b"remotefilelog", b"servercachepath") | ||||
| if not cachepath: | if not cachepath: | ||||
| cachepath = os.path.join(repo.path, b"remotefilelogcache") | cachepath = os.path.join(repo.path, b"remotefilelogcache") | ||||
| while True: | while True: | ||||
| request = fin.readline()[:-1] | request = fin.readline()[:-1] | ||||
| if not request: | if not request: | ||||
| break | break | ||||
| node = bin(request[:40]) | node = bin(request[:40]) | ||||
| if node == nullid: | if node == repo.nullid: | ||||
| yield b'0\n' | yield b'0\n' | ||||
| continue | continue | ||||
| path = request[40:] | path = request[40:] | ||||
| text = _loadfileblob(repo, cachepath, path, node) | text = _loadfileblob(repo, cachepath, path, node) | ||||
| yield b'%d\n%s' % (len(text), text) | yield b'%d\n%s' % (len(text), text) | ||||
| try: | try: | ||||
| repo.forcelinkrev = True | repo.forcelinkrev = True | ||||
| ancestors.extend([f for f in filectx.ancestors()]) | ancestors.extend([f for f in filectx.ancestors()]) | ||||
| ancestortext = b"" | ancestortext = b"" | ||||
| for ancestorctx in ancestors: | for ancestorctx in ancestors: | ||||
| parents = ancestorctx.parents() | parents = ancestorctx.parents() | ||||
| p1 = nullid | p1 = repo.nullid | ||||
| p2 = nullid | p2 = repo.nullid | ||||
| if len(parents) > 0: | if len(parents) > 0: | ||||
| p1 = parents[0].filenode() | p1 = parents[0].filenode() | ||||
| if len(parents) > 1: | if len(parents) > 1: | ||||
| p2 = parents[1].filenode() | p2 = parents[1].filenode() | ||||
| copyname = b"" | copyname = b"" | ||||
| rename = ancestorctx.renamed() | rename = ancestorctx.renamed() | ||||
| if rename: | if rename: | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import os | import os | ||||
| import time | import time | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import short | ||||
| nullid, | |||||
| short, | |||||
| ) | |||||
| from mercurial import ( | from mercurial import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| lock as lockmod, | lock as lockmod, | ||||
| mdiff, | mdiff, | ||||
| policy, | policy, | ||||
| pycompat, | pycompat, | ||||
| scmutil, | scmutil, | ||||
| ui.debug( | ui.debug( | ||||
| b"%s: orphan chain: %s\n" | b"%s: orphan chain: %s\n" | ||||
| % (filename, b", ".join([short(s) for s in orphans])) | % (filename, b", ".join([short(s) for s in orphans])) | ||||
| ) | ) | ||||
| # Create one contiguous chain and reassign deltabases. | # Create one contiguous chain and reassign deltabases. | ||||
| for i, node in enumerate(orphans): | for i, node in enumerate(orphans): | ||||
| if i == 0: | if i == 0: | ||||
| deltabases[node] = (nullid, 0) | deltabases[node] = (self.repo.nullid, 0) | ||||
| else: | else: | ||||
| parent = orphans[i - 1] | parent = orphans[i - 1] | ||||
| deltabases[node] = (parent, deltabases[parent][1] + 1) | deltabases[node] = (parent, deltabases[parent][1] + 1) | ||||
| nodes = [n for n in nodes if n not in orphans] | nodes = [n for n in nodes if n not in orphans] | ||||
| nodes += orphans | nodes += orphans | ||||
| return nodes | return nodes | ||||
| def repackdata(self, ledger, target): | def repackdata(self, ledger, target): | ||||
| ) | ) | ||||
| for i, node in enumerate(orderednodes): | for i, node in enumerate(orderednodes): | ||||
| processprogress.update(i) | processprogress.update(i) | ||||
| # Find delta base | # Find delta base | ||||
| # TODO: allow delta'ing against most recent descendant instead | # TODO: allow delta'ing against most recent descendant instead | ||||
| # of immediate child | # of immediate child | ||||
| deltatuple = deltabases.get(node, None) | deltatuple = deltabases.get(node, None) | ||||
| if deltatuple is None: | if deltatuple is None: | ||||
| deltabase, chainlen = nullid, 0 | deltabase, chainlen = self.repo.nullid, 0 | ||||
| deltabases[node] = (nullid, 0) | deltabases[node] = (self.repo.nullid, 0) | ||||
| nobase.add(node) | nobase.add(node) | ||||
| else: | else: | ||||
| deltabase, chainlen = deltatuple | deltabase, chainlen = deltatuple | ||||
| referenced.add(deltabase) | referenced.add(deltabase) | ||||
| # Use available ancestor information to inform our delta choices | # Use available ancestor information to inform our delta choices | ||||
| ancestorinfo = ancestors.get(node) | ancestorinfo = ancestors.get(node) | ||||
| if ancestorinfo: | if ancestorinfo: | ||||
| p1, p2, linknode, copyfrom = ancestorinfo | p1, p2, linknode, copyfrom = ancestorinfo | ||||
| # The presence of copyfrom means we're at a point where the | # The presence of copyfrom means we're at a point where the | ||||
| # file was copied from elsewhere. So don't attempt to do any | # file was copied from elsewhere. So don't attempt to do any | ||||
| # deltas with the other file. | # deltas with the other file. | ||||
| if copyfrom: | if copyfrom: | ||||
| p1 = nullid | p1 = self.repo.nullid | ||||
| if chainlen < maxchainlen: | if chainlen < maxchainlen: | ||||
| # Record this child as the delta base for its parents. | # Record this child as the delta base for its parents. | ||||
| # This may be non optimal, since the parents may have | # This may be non optimal, since the parents may have | ||||
| # many children, and this will only choose the last one. | # many children, and this will only choose the last one. | ||||
| # TODO: record all children and try all deltas to find | # TODO: record all children and try all deltas to find | ||||
| # best | # best | ||||
| if p1 != nullid: | if p1 != self.repo.nullid: | ||||
| deltabases[p1] = (node, chainlen + 1) | deltabases[p1] = (node, chainlen + 1) | ||||
| if p2 != nullid: | if p2 != self.repo.nullid: | ||||
| deltabases[p2] = (node, chainlen + 1) | deltabases[p2] = (node, chainlen + 1) | ||||
| # experimental config: repack.chainorphansbysize | # experimental config: repack.chainorphansbysize | ||||
| if ui.configbool(b'repack', b'chainorphansbysize'): | if ui.configbool(b'repack', b'chainorphansbysize'): | ||||
| orphans = nobase - referenced | orphans = nobase - referenced | ||||
| orderednodes = self._chainorphans( | orderednodes = self._chainorphans( | ||||
| ui, filename, orderednodes, orphans, deltabases | ui, filename, orderednodes, orphans, deltabases | ||||
| ) | ) | ||||
| # Compute deltas and write to the pack | # Compute deltas and write to the pack | ||||
| for i, node in enumerate(orderednodes): | for i, node in enumerate(orderednodes): | ||||
| deltabase, chainlen = deltabases[node] | deltabase, chainlen = deltabases[node] | ||||
| # Compute delta | # Compute delta | ||||
| # TODO: Optimize the deltachain fetching. Since we're | # TODO: Optimize the deltachain fetching. Since we're | ||||
| # iterating over the different version of the file, we may | # iterating over the different version of the file, we may | ||||
| # be fetching the same deltachain over and over again. | # be fetching the same deltachain over and over again. | ||||
| if deltabase != nullid: | if deltabase != self.repo.nullid: | ||||
| deltaentry = self.data.getdelta(filename, node) | deltaentry = self.data.getdelta(filename, node) | ||||
| delta, deltabasename, origdeltabase, meta = deltaentry | delta, deltabasename, origdeltabase, meta = deltaentry | ||||
| size = meta.get(constants.METAKEYSIZE) | size = meta.get(constants.METAKEYSIZE) | ||||
| if ( | if ( | ||||
| deltabasename != filename | deltabasename != filename | ||||
| or origdeltabase != deltabase | or origdeltabase != deltabase | ||||
| or size is None | or size is None | ||||
| ): | ): | ||||
| # Usually this happens if the file was copied to another file, | # Usually this happens if the file was copied to another file, | ||||
| # then the copy was deleted, then reintroduced without copy | # then the copy was deleted, then reintroduced without copy | ||||
| # metadata. The original add and the new add have the same hash | # metadata. The original add and the new add have the same hash | ||||
| # since the content is identical and the parents are null. | # since the content is identical and the parents are null. | ||||
| if node in dontprocess and node not in entries: | if node in dontprocess and node not in entries: | ||||
| # If copyfrom == filename, it means the copy history | # If copyfrom == filename, it means the copy history | ||||
| # went to come other file, then came back to this one, so we | # went to come other file, then came back to this one, so we | ||||
| # should continue processing it. | # should continue processing it. | ||||
| if p1 != nullid and copyfrom != filename: | if p1 != self.repo.nullid and copyfrom != filename: | ||||
| dontprocess.add(p1) | dontprocess.add(p1) | ||||
| if p2 != nullid: | if p2 != self.repo.nullid: | ||||
| dontprocess.add(p2) | dontprocess.add(p2) | ||||
| continue | continue | ||||
| if copyfrom: | if copyfrom: | ||||
| dontprocess.add(p1) | dontprocess.add(p1) | ||||
| target.add(filename, node, p1, p2, linknode, copyfrom) | target.add(filename, node, p1, p2, linknode, copyfrom) | ||||
| if node in entries: | if node in entries: | ||||
| entries[node].historyrepacked = True | entries[node].historyrepacked = True | ||||
| progress.increment() | progress.increment() | ||||
| progress.complete() | progress.complete() | ||||
| target.close(ledger=ledger) | target.close(ledger=ledger) | ||||
| def _toposort(self, ancestors): | def _toposort(self, ancestors): | ||||
| def parentfunc(node): | def parentfunc(node): | ||||
| p1, p2, linknode, copyfrom = ancestors[node] | p1, p2, linknode, copyfrom = ancestors[node] | ||||
| parents = [] | parents = [] | ||||
| if p1 != nullid: | if p1 != self.repo.nullid: | ||||
| parents.append(p1) | parents.append(p1) | ||||
| if p2 != nullid: | if p2 != self.repo.nullid: | ||||
| parents.append(p2) | parents.append(p2) | ||||
| return parents | return parents | ||||
| sortednodes = shallowutil.sortnodes(ancestors.keys(), parentfunc) | sortednodes = shallowutil.sortnodes(ancestors.keys(), parentfunc) | ||||
| return sortednodes | return sortednodes | ||||
| class repackledger(object): | class repackledger(object): | ||||
| # shallowbundle.py - bundle10 implementation for use with shallow repositories | # shallowbundle.py - bundle10 implementation for use with shallow repositories | ||||
| # | # | ||||
| # Copyright 2013 Facebook, Inc. | # Copyright 2013 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import bin, hex, nullid | from mercurial.node import bin, hex | ||||
| from mercurial import ( | from mercurial import ( | ||||
| bundlerepo, | bundlerepo, | ||||
| changegroup, | changegroup, | ||||
| error, | error, | ||||
| match, | match, | ||||
| mdiff, | mdiff, | ||||
| pycompat, | pycompat, | ||||
| ) | ) | ||||
| for fnode in missing: | for fnode in missing: | ||||
| fctx = repo.filectx(rlog.filename, fileid=fnode) | fctx = repo.filectx(rlog.filename, fileid=fnode) | ||||
| if fctx.linkrev() not in commonrevs: | if fctx.linkrev() not in commonrevs: | ||||
| results.append(fnode) | results.append(fnode) | ||||
| return results | return results | ||||
| def nodechunk(self, revlog, node, prevnode, linknode): | def nodechunk(self, revlog, node, prevnode, linknode): | ||||
| prefix = b'' | prefix = b'' | ||||
| if prevnode == nullid: | if prevnode == revlog.nullid: | ||||
| delta = revlog.rawdata(node) | delta = revlog.rawdata(node) | ||||
| prefix = mdiff.trivialdiffheader(len(delta)) | prefix = mdiff.trivialdiffheader(len(delta)) | ||||
| else: | else: | ||||
| # Actually uses remotefilelog.revdiff which works on nodes, not revs | # Actually uses remotefilelog.revdiff which works on nodes, not revs | ||||
| delta = revlog.revdiff(prevnode, node) | delta = revlog.revdiff(prevnode, node) | ||||
| p1, p2 = revlog.parents(node) | p1, p2 = revlog.parents(node) | ||||
| flags = revlog.flags(node) | flags = revlog.flags(node) | ||||
| meta = self.builddeltaheader(node, p1, p2, prevnode, linknode, flags) | meta = self.builddeltaheader(node, p1, p2, prevnode, linknode, flags) | ||||
| visited.add(f) | visited.add(f) | ||||
| if chain is None: | if chain is None: | ||||
| raise error.Abort(_(b"received file revlog group is empty")) | raise error.Abort(_(b"received file revlog group is empty")) | ||||
| processed = set() | processed = set() | ||||
| def available(f, node, depf, depnode): | def available(f, node, depf, depnode): | ||||
| if depnode != nullid and (depf, depnode) not in processed: | if depnode != repo.nullid and (depf, depnode) not in processed: | ||||
| if not (depf, depnode) in revisiondatas: | if not (depf, depnode) in revisiondatas: | ||||
| # It's not in the changegroup, assume it's already | # It's not in the changegroup, assume it's already | ||||
| # in the repo | # in the repo | ||||
| return True | return True | ||||
| # re-add self to queue | # re-add self to queue | ||||
| queue.insert(0, (f, node)) | queue.insert(0, (f, node)) | ||||
| # add dependency in front | # add dependency in front | ||||
| queue.insert(0, (depf, depnode)) | queue.insert(0, (depf, depnode)) | ||||
| return False | return False | ||||
| return True | return True | ||||
| skipcount = 0 | skipcount = 0 | ||||
| # Prefetch the non-bundled revisions that we will need | # Prefetch the non-bundled revisions that we will need | ||||
| prefetchfiles = [] | prefetchfiles = [] | ||||
| for f, node in queue: | for f, node in queue: | ||||
| revisiondata = revisiondatas[(f, node)] | revisiondata = revisiondatas[(f, node)] | ||||
| # revisiondata: (node, p1, p2, cs, deltabase, delta, flags) | # revisiondata: (node, p1, p2, cs, deltabase, delta, flags) | ||||
| dependents = [revisiondata[1], revisiondata[2], revisiondata[4]] | dependents = [revisiondata[1], revisiondata[2], revisiondata[4]] | ||||
| for dependent in dependents: | for dependent in dependents: | ||||
| if dependent == nullid or (f, dependent) in revisiondatas: | if dependent == repo.nullid or (f, dependent) in revisiondatas: | ||||
| continue | continue | ||||
| prefetchfiles.append((f, hex(dependent))) | prefetchfiles.append((f, hex(dependent))) | ||||
| repo.fileservice.prefetch(prefetchfiles) | repo.fileservice.prefetch(prefetchfiles) | ||||
| # Apply the revisions in topological order such that a revision | # Apply the revisions in topological order such that a revision | ||||
| # is only written once it's deltabase and parents have been written. | # is only written once it's deltabase and parents have been written. | ||||
| while queue: | while queue: | ||||
| meta, text = shallowutil.parsemeta(text) | meta, text = shallowutil.parsemeta(text) | ||||
| if b'copy' in meta: | if b'copy' in meta: | ||||
| copyfrom = meta[b'copy'] | copyfrom = meta[b'copy'] | ||||
| copynode = bin(meta[b'copyrev']) | copynode = bin(meta[b'copyrev']) | ||||
| if not available(f, node, copyfrom, copynode): | if not available(f, node, copyfrom, copynode): | ||||
| continue | continue | ||||
| for p in [p1, p2]: | for p in [p1, p2]: | ||||
| if p != nullid: | if p != repo.nullid: | ||||
| if not available(f, node, f, p): | if not available(f, node, f, p): | ||||
| continue | continue | ||||
| fl.add(text, meta, trp, linknode, p1, p2) | fl.add(text, meta, trp, linknode, p1, p2) | ||||
| processed.add((f, node)) | processed.add((f, node)) | ||||
| skipcount = 0 | skipcount = 0 | ||||
| progress.complete() | progress.complete() | ||||
| return len(revisiondatas), newfiles | return len(revisiondatas), newfiles | ||||
| # shallowrepo.py - shallow repository that uses remote filelogs | # shallowrepo.py - shallow repository that uses remote filelogs | ||||
| # | # | ||||
| # Copyright 2013 Facebook, Inc. | # Copyright 2013 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import os | import os | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import hex, nullid, nullrev | from mercurial.node import hex, nullrev | ||||
| from mercurial import ( | from mercurial import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| localrepo, | localrepo, | ||||
| match, | match, | ||||
| pycompat, | pycompat, | ||||
| scmutil, | scmutil, | ||||
| sparse, | sparse, | ||||
| # some contexts already have manifest nodes, they don't need any | # some contexts already have manifest nodes, they don't need any | ||||
| # prefetching (for example if we're just editing a commit message | # prefetching (for example if we're just editing a commit message | ||||
| # we can reuse manifest | # we can reuse manifest | ||||
| if not ctx.manifestnode(): | if not ctx.manifestnode(): | ||||
| # prefetch files that will likely be compared | # prefetch files that will likely be compared | ||||
| m1 = ctx.p1().manifest() | m1 = ctx.p1().manifest() | ||||
| files = [] | files = [] | ||||
| for f in ctx.modified() + ctx.added(): | for f in ctx.modified() + ctx.added(): | ||||
| fparent1 = m1.get(f, nullid) | fparent1 = m1.get(f, self.nullid) | ||||
| if fparent1 != nullid: | if fparent1 != self.nullid: | ||||
| files.append((f, hex(fparent1))) | files.append((f, hex(fparent1))) | ||||
| self.fileservice.prefetch(files) | self.fileservice.prefetch(files) | ||||
| return super(shallowrepository, self).commitctx( | return super(shallowrepository, self).commitctx( | ||||
| ctx, error=error, origctx=origctx | ctx, error=error, origctx=origctx | ||||
| ) | ) | ||||
| def backgroundprefetch( | def backgroundprefetch( | ||||
| self, revs, base=None, repack=False, pats=None, opts=None | self, revs, base=None, repack=False, pats=None, opts=None | ||||
| import sqlite3 | import sqlite3 | ||||
| import struct | import struct | ||||
| import threading | import threading | ||||
| import zlib | import zlib | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| sha1nodeconstants, | sha1nodeconstants, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from mercurial.thirdparty import attr | from mercurial.thirdparty import attr | ||||
| from mercurial import ( | from mercurial import ( | ||||
| ancestor, | ancestor, | ||||
| dagop, | dagop, | ||||
| rid, rev, node, p1rev, p2rev, linkrev, flags = row | rid, rev, node, p1rev, p2rev, linkrev, flags = row | ||||
| if i != rev: | if i != rev: | ||||
| raise SQLiteStoreError( | raise SQLiteStoreError( | ||||
| _(b'sqlite database has inconsistent revision numbers') | _(b'sqlite database has inconsistent revision numbers') | ||||
| ) | ) | ||||
| if p1rev == nullrev: | if p1rev == nullrev: | ||||
| p1node = nullid | p1node = sha1nodeconstants.nullid | ||||
| else: | else: | ||||
| p1node = self._revtonode[p1rev] | p1node = self._revtonode[p1rev] | ||||
| if p2rev == nullrev: | if p2rev == nullrev: | ||||
| p2node = nullid | p2node = sha1nodeconstants.nullid | ||||
| else: | else: | ||||
| p2node = self._revtonode[p2rev] | p2node = self._revtonode[p2rev] | ||||
| entry = revisionentry( | entry = revisionentry( | ||||
| rid=rid, | rid=rid, | ||||
| rev=rev, | rev=rev, | ||||
| node=node, | node=node, | ||||
| p1rev=p1rev, | p1rev=p1rev, | ||||
| def __len__(self): | def __len__(self): | ||||
| return len(self._revisions) | return len(self._revisions) | ||||
| def __iter__(self): | def __iter__(self): | ||||
| return iter(pycompat.xrange(len(self._revisions))) | return iter(pycompat.xrange(len(self._revisions))) | ||||
| def hasnode(self, node): | def hasnode(self, node): | ||||
| if node == nullid: | if node == sha1nodeconstants.nullid: | ||||
| return False | return False | ||||
| return node in self._nodetorev | return node in self._nodetorev | ||||
| def revs(self, start=0, stop=None): | def revs(self, start=0, stop=None): | ||||
| return storageutil.iterrevs( | return storageutil.iterrevs( | ||||
| len(self._revisions), start=start, stop=stop | len(self._revisions), start=start, stop=stop | ||||
| ) | ) | ||||
| def parents(self, node): | def parents(self, node): | ||||
| if node == nullid: | if node == sha1nodeconstants.nullid: | ||||
| return nullid, nullid | return sha1nodeconstants.nullid, sha1nodeconstants.nullid | ||||
| if node not in self._revisions: | if node not in self._revisions: | ||||
| raise error.LookupError(node, self._path, _(b'no node')) | raise error.LookupError(node, self._path, _(b'no node')) | ||||
| entry = self._revisions[node] | entry = self._revisions[node] | ||||
| return entry.p1node, entry.p2node | return entry.p1node, entry.p2node | ||||
| def parentrevs(self, rev): | def parentrevs(self, rev): | ||||
| if rev == nullrev: | if rev == nullrev: | ||||
| return nullrev, nullrev | return nullrev, nullrev | ||||
| if rev not in self._revtonode: | if rev not in self._revtonode: | ||||
| raise IndexError(rev) | raise IndexError(rev) | ||||
| entry = self._revisions[self._revtonode[rev]] | entry = self._revisions[self._revtonode[rev]] | ||||
| return entry.p1rev, entry.p2rev | return entry.p1rev, entry.p2rev | ||||
| def rev(self, node): | def rev(self, node): | ||||
| if node == nullid: | if node == sha1nodeconstants.nullid: | ||||
| return nullrev | return nullrev | ||||
| if node not in self._nodetorev: | if node not in self._nodetorev: | ||||
| raise error.LookupError(node, self._path, _(b'no node')) | raise error.LookupError(node, self._path, _(b'no node')) | ||||
| return self._nodetorev[node] | return self._nodetorev[node] | ||||
| def node(self, rev): | def node(self, rev): | ||||
| if rev == nullrev: | if rev == nullrev: | ||||
| return nullid | return sha1nodeconstants.nullid | ||||
| if rev not in self._revtonode: | if rev not in self._revtonode: | ||||
| raise IndexError(rev) | raise IndexError(rev) | ||||
| return self._revtonode[rev] | return self._revtonode[rev] | ||||
| def lookup(self, node): | def lookup(self, node): | ||||
| return storageutil.fileidlookup(self, node, self._path) | return storageutil.fileidlookup(self, node, self._path) | ||||
| def descendants(self, revs): | def descendants(self, revs): | ||||
| # TODO we could implement this using a recursive SQL query, which | # TODO we could implement this using a recursive SQL query, which | ||||
| # might be faster. | # might be faster. | ||||
| return dagop.descendantrevs(revs, self.revs, self.parentrevs) | return dagop.descendantrevs(revs, self.revs, self.parentrevs) | ||||
| def heads(self, start=None, stop=None): | def heads(self, start=None, stop=None): | ||||
| if start is None and stop is None: | if start is None and stop is None: | ||||
| if not len(self): | if not len(self): | ||||
| return [nullid] | return [sha1nodeconstants.nullid] | ||||
| startrev = self.rev(start) if start is not None else nullrev | startrev = self.rev(start) if start is not None else nullrev | ||||
| stoprevs = {self.rev(n) for n in stop or []} | stoprevs = {self.rev(n) for n in stop or []} | ||||
| revs = dagop.headrevssubset( | revs = dagop.headrevssubset( | ||||
| self.revs, self.parentrevs, startrev=startrev, stoprevs=stoprevs | self.revs, self.parentrevs, startrev=startrev, stoprevs=stoprevs | ||||
| ) | ) | ||||
| node = self._revtonode[rev] | node = self._revtonode[rev] | ||||
| if self.renamed(node): | if self.renamed(node): | ||||
| return len(self.read(node)) | return len(self.read(node)) | ||||
| return len(self.revision(node)) | return len(self.revision(node)) | ||||
| def revision(self, node, raw=False, _verifyhash=True): | def revision(self, node, raw=False, _verifyhash=True): | ||||
| if node in (nullid, nullrev): | if node in (sha1nodeconstants.nullid, nullrev): | ||||
| return b'' | return b'' | ||||
| if isinstance(node, int): | if isinstance(node, int): | ||||
| node = self.node(node) | node = self.node(node) | ||||
| if node not in self._nodetorev: | if node not in self._nodetorev: | ||||
| raise error.LookupError(node, self._path, _(b'no node')) | raise error.LookupError(node, self._path, _(b'no node')) | ||||
| deltamode=repository.CG_DELTAMODE_STD, | deltamode=repository.CG_DELTAMODE_STD, | ||||
| sidedata_helpers=None, | sidedata_helpers=None, | ||||
| ): | ): | ||||
| if nodesorder not in (b'nodes', b'storage', b'linear', None): | if nodesorder not in (b'nodes', b'storage', b'linear', None): | ||||
| raise error.ProgrammingError( | raise error.ProgrammingError( | ||||
| b'unhandled value for nodesorder: %s' % nodesorder | b'unhandled value for nodesorder: %s' % nodesorder | ||||
| ) | ) | ||||
| nodes = [n for n in nodes if n != nullid] | nodes = [n for n in nodes if n != sha1nodeconstants.nullid] | ||||
| if not nodes: | if not nodes: | ||||
| return | return | ||||
| # TODO perform in a single query. | # TODO perform in a single query. | ||||
| res = self._db.execute( | res = self._db.execute( | ||||
| 'SELECT revnum, deltaid FROM fileindex ' | 'SELECT revnum, deltaid FROM fileindex ' | ||||
| 'WHERE pathid=? ' | 'WHERE pathid=? ' | ||||
| if wireflags & repository.REVISION_FLAG_CENSORED: | if wireflags & repository.REVISION_FLAG_CENSORED: | ||||
| storeflags |= FLAG_CENSORED | storeflags |= FLAG_CENSORED | ||||
| if wireflags & ~repository.REVISION_FLAG_CENSORED: | if wireflags & ~repository.REVISION_FLAG_CENSORED: | ||||
| raise SQLiteStoreError(b'unhandled revision flag') | raise SQLiteStoreError(b'unhandled revision flag') | ||||
| if maybemissingparents: | if maybemissingparents: | ||||
| if p1 != nullid and not self.hasnode(p1): | if p1 != sha1nodeconstants.nullid and not self.hasnode(p1): | ||||
| p1 = nullid | p1 = sha1nodeconstants.nullid | ||||
| storeflags |= FLAG_MISSING_P1 | storeflags |= FLAG_MISSING_P1 | ||||
| if p2 != nullid and not self.hasnode(p2): | if p2 != sha1nodeconstants.nullid and not self.hasnode(p2): | ||||
| p2 = nullid | p2 = sha1nodeconstants.nullid | ||||
| storeflags |= FLAG_MISSING_P2 | storeflags |= FLAG_MISSING_P2 | ||||
| baserev = self.rev(deltabase) | baserev = self.rev(deltabase) | ||||
| # If base is censored, delta must be full replacement in a single | # If base is censored, delta must be full replacement in a single | ||||
| # patch operation. | # patch operation. | ||||
| if baserev != nullrev and self.iscensored(baserev): | if baserev != nullrev and self.iscensored(baserev): | ||||
| hlen = struct.calcsize(b'>lll') | hlen = struct.calcsize(b'>lll') | ||||
| storeflags |= FLAG_CENSORED | storeflags |= FLAG_CENSORED | ||||
| linkrev = linkmapper(linknode) | linkrev = linkmapper(linknode) | ||||
| if node in self._revisions: | if node in self._revisions: | ||||
| # Possibly reset parents to make them proper. | # Possibly reset parents to make them proper. | ||||
| entry = self._revisions[node] | entry = self._revisions[node] | ||||
| if entry.flags & FLAG_MISSING_P1 and p1 != nullid: | if ( | ||||
| entry.flags & FLAG_MISSING_P1 | |||||
| and p1 != sha1nodeconstants.nullid | |||||
| ): | |||||
| entry.p1node = p1 | entry.p1node = p1 | ||||
| entry.p1rev = self._nodetorev[p1] | entry.p1rev = self._nodetorev[p1] | ||||
| entry.flags &= ~FLAG_MISSING_P1 | entry.flags &= ~FLAG_MISSING_P1 | ||||
| self._db.execute( | self._db.execute( | ||||
| 'UPDATE fileindex SET p1rev=?, flags=? WHERE id=?', | 'UPDATE fileindex SET p1rev=?, flags=? WHERE id=?', | ||||
| (self._nodetorev[p1], entry.flags, entry.rid), | (self._nodetorev[p1], entry.flags, entry.rid), | ||||
| ) | ) | ||||
| if entry.flags & FLAG_MISSING_P2 and p2 != nullid: | if ( | ||||
| entry.flags & FLAG_MISSING_P2 | |||||
| and p2 != sha1nodeconstants.nullid | |||||
| ): | |||||
| entry.p2node = p2 | entry.p2node = p2 | ||||
| entry.p2rev = self._nodetorev[p2] | entry.p2rev = self._nodetorev[p2] | ||||
| entry.flags &= ~FLAG_MISSING_P2 | entry.flags &= ~FLAG_MISSING_P2 | ||||
| self._db.execute( | self._db.execute( | ||||
| 'UPDATE fileindex SET p2rev=?, flags=? WHERE id=?', | 'UPDATE fileindex SET p2rev=?, flags=? WHERE id=?', | ||||
| (self._nodetorev[p1], entry.flags, entry.rid), | (self._nodetorev[p1], entry.flags, entry.rid), | ||||
| ) | ) | ||||
| if duplicaterevisioncb: | if duplicaterevisioncb: | ||||
| duplicaterevisioncb(self, self.rev(node)) | duplicaterevisioncb(self, self.rev(node)) | ||||
| empty = False | empty = False | ||||
| continue | continue | ||||
| if deltabase == nullid: | if deltabase == sha1nodeconstants.nullid: | ||||
| text = mdiff.patch(b'', delta) | text = mdiff.patch(b'', delta) | ||||
| storedelta = None | storedelta = None | ||||
| else: | else: | ||||
| text = None | text = None | ||||
| storedelta = (deltabase, delta) | storedelta = (deltabase, delta) | ||||
| rev = self._addrawrevision( | rev = self._addrawrevision( | ||||
| node, | node, | ||||
| if isinstance(deltabase, int): | if isinstance(deltabase, int): | ||||
| deltabase = self.node(deltabase) | deltabase = self.node(deltabase) | ||||
| else: | else: | ||||
| assert revisiondata is not None | assert revisiondata is not None | ||||
| deltabase = p1 | deltabase = p1 | ||||
| if deltabase == nullid: | if deltabase == sha1nodeconstants.nullid: | ||||
| delta = revisiondata | delta = revisiondata | ||||
| else: | else: | ||||
| delta = mdiff.textdiff( | delta = mdiff.textdiff( | ||||
| self.revision(self.rev(deltabase)), revisiondata | self.revision(self.rev(deltabase)), revisiondata | ||||
| ) | ) | ||||
| # File index stores a pointer to its delta and the parent delta. | # File index stores a pointer to its delta and the parent delta. | ||||
| # The parent delta is stored via a pointer to the fileindex PK. | # The parent delta is stored via a pointer to the fileindex PK. | ||||
| if deltabase == nullid: | if deltabase == sha1nodeconstants.nullid: | ||||
| baseid = None | baseid = None | ||||
| else: | else: | ||||
| baseid = self._revisions[deltabase].rid | baseid = self._revisions[deltabase].rid | ||||
| # Deltas are stored with a hash of their content. This allows | # Deltas are stored with a hash of their content. This allows | ||||
| # us to de-duplicate. The table is configured to ignore conflicts | # us to de-duplicate. The table is configured to ignore conflicts | ||||
| # and it is faster to just insert and silently noop than to look | # and it is faster to just insert and silently noop than to look | ||||
| # first. | # first. | ||||
| if len(deltablob) >= len(delta): | if len(deltablob) >= len(delta): | ||||
| deltablob = delta | deltablob = delta | ||||
| compression = COMPRESSION_NONE | compression = COMPRESSION_NONE | ||||
| deltaid = insertdelta(self._db, compression, deltahash, deltablob) | deltaid = insertdelta(self._db, compression, deltahash, deltablob) | ||||
| rev = len(self) | rev = len(self) | ||||
| if p1 == nullid: | if p1 == sha1nodeconstants.nullid: | ||||
| p1rev = nullrev | p1rev = nullrev | ||||
| else: | else: | ||||
| p1rev = self._nodetorev[p1] | p1rev = self._nodetorev[p1] | ||||
| if p2 == nullid: | if p2 == sha1nodeconstants.nullid: | ||||
| p2rev = nullrev | p2rev = nullrev | ||||
| else: | else: | ||||
| p2rev = self._nodetorev[p2] | p2rev = self._nodetorev[p2] | ||||
| rid = self._db.execute( | rid = self._db.execute( | ||||
| 'INSERT INTO fileindex (' | 'INSERT INTO fileindex (' | ||||
| ' pathid, revnum, node, p1rev, p2rev, linkrev, flags, ' | ' pathid, revnum, node, p1rev, p2rev, linkrev, flags, ' | ||||
| ' deltaid, deltabaseid) ' | ' deltaid, deltabaseid) ' | ||||
| import os | import os | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.pycompat import open | from mercurial.pycompat import open | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| short, | short, | ||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| bundlerepo, | bundlerepo, | ||||
| cmdutil, | cmdutil, | ||||
| error, | error, | ||||
| exchange, | exchange, | ||||
| hg, | hg, | ||||
| if list: | if list: | ||||
| del list[list.index(transplant)] | del list[list.index(transplant)] | ||||
| self.dirty = True | self.dirty = True | ||||
| class transplanter(object): | class transplanter(object): | ||||
| def __init__(self, ui, repo, opts): | def __init__(self, ui, repo, opts): | ||||
| self.ui = ui | self.ui = ui | ||||
| self.repo = repo | |||||
| self.path = repo.vfs.join(b'transplant') | self.path = repo.vfs.join(b'transplant') | ||||
| self.opener = vfsmod.vfs(self.path) | self.opener = vfsmod.vfs(self.path) | ||||
| self.transplants = transplants( | self.transplants = transplants( | ||||
| self.path, b'transplants', opener=self.opener | self.path, b'transplants', opener=self.opener | ||||
| ) | ) | ||||
| def getcommiteditor(): | def getcommiteditor(): | ||||
| editform = cmdutil.mergeeditform(repo[None], b'transplant') | editform = cmdutil.mergeeditform(repo[None], b'transplant') | ||||
| # pulling all the merge revs at once would mean we | # pulling all the merge revs at once would mean we | ||||
| # couldn't transplant after the latest even if | # couldn't transplant after the latest even if | ||||
| # transplants before them fail. | # transplants before them fail. | ||||
| domerge = True | domerge = True | ||||
| if not hasnode(repo, node): | if not hasnode(repo, node): | ||||
| exchange.pull(repo, source.peer(), heads=[node]) | exchange.pull(repo, source.peer(), heads=[node]) | ||||
| skipmerge = False | skipmerge = False | ||||
| if parents[1] != nullid: | if parents[1] != repo.nullid: | ||||
| if not opts.get(b'parent'): | if not opts.get(b'parent'): | ||||
| self.ui.note( | self.ui.note( | ||||
| _(b'skipping merge changeset %d:%s\n') | _(b'skipping merge changeset %d:%s\n') | ||||
| % (rev, short(node)) | % (rev, short(node)) | ||||
| ) | ) | ||||
| skipmerge = True | skipmerge = True | ||||
| else: | else: | ||||
| parent = source.lookup(opts[b'parent']) | parent = source.lookup(opts[b'parent']) | ||||
| series.write(b'# Merges\n') | series.write(b'# Merges\n') | ||||
| for m in merges: | for m in merges: | ||||
| series.write(hex(m) + b'\n') | series.write(hex(m) + b'\n') | ||||
| series.close() | series.close() | ||||
| def parselog(self, fp): | def parselog(self, fp): | ||||
| parents = [] | parents = [] | ||||
| message = [] | message = [] | ||||
| node = nullid | node = self.repo.nullid | ||||
| inmsg = False | inmsg = False | ||||
| user = None | user = None | ||||
| date = None | date = None | ||||
| for line in fp.read().splitlines(): | for line in fp.read().splitlines(): | ||||
| if inmsg: | if inmsg: | ||||
| message.append(line) | message.append(line) | ||||
| elif line.startswith(b'# User '): | elif line.startswith(b'# User '): | ||||
| user = line[7:] | user = line[7:] | ||||
| absdst = os.path.join(self.path, b'journal') | absdst = os.path.join(self.path, b'journal') | ||||
| if os.path.exists(absdst): | if os.path.exists(absdst): | ||||
| os.unlink(absdst) | os.unlink(absdst) | ||||
| def transplantfilter(self, repo, source, root): | def transplantfilter(self, repo, source, root): | ||||
| def matchfn(node): | def matchfn(node): | ||||
| if self.applied(repo, node, root): | if self.applied(repo, node, root): | ||||
| return False | return False | ||||
| if source.changelog.parents(node)[1] != nullid: | if source.changelog.parents(node)[1] != repo.nullid: | ||||
| return False | return False | ||||
| extra = source.changelog.read(node)[5] | extra = source.changelog.read(node)[5] | ||||
| cnode = extra.get(b'transplant_source') | cnode = extra.get(b'transplant_source') | ||||
| if cnode and self.applied(repo, cnode, root): | if cnode and self.applied(repo, cnode, root): | ||||
| return False | return False | ||||
| return True | return True | ||||
| return matchfn | return matchfn | ||||
| opts[b'log'] = ui.config(b'transplant', b'log') | opts[b'log'] = ui.config(b'transplant', b'log') | ||||
| if not opts.get(b'filter'): | if not opts.get(b'filter'): | ||||
| # deprecated config: transplant.filter | # deprecated config: transplant.filter | ||||
| opts[b'filter'] = ui.config(b'transplant', b'filter') | opts[b'filter'] = ui.config(b'transplant', b'filter') | ||||
| tp = transplanter(ui, repo, opts) | tp = transplanter(ui, repo, opts) | ||||
| p1 = repo.dirstate.p1() | p1 = repo.dirstate.p1() | ||||
| if len(repo) > 0 and p1 == nullid: | if len(repo) > 0 and p1 == repo.nullid: | ||||
| raise error.Abort(_(b'no revision checked out')) | raise error.Abort(_(b'no revision checked out')) | ||||
| if opts.get(b'continue'): | if opts.get(b'continue'): | ||||
| if not tp.canresume(): | if not tp.canresume(): | ||||
| raise error.StateError(_(b'no transplant to continue')) | raise error.StateError(_(b'no transplant to continue')) | ||||
| elif opts.get(b'stop'): | elif opts.get(b'stop'): | ||||
| if not tp.canresume(): | if not tp.canresume(): | ||||
| raise error.StateError(_(b'no interrupted transplant found')) | raise error.StateError(_(b'no interrupted transplant found')) | ||||
| return tp.stop(ui, repo) | return tp.stop(ui, repo) | ||||
| files to their uncommitted state. This means that files modified, added or | files to their uncommitted state. This means that files modified, added or | ||||
| removed in the changeset will be left unchanged, and so will remain modified, | removed in the changeset will be left unchanged, and so will remain modified, | ||||
| added and removed in the working directory. | added and removed in the working directory. | ||||
| """ | """ | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import nullid | |||||
| from mercurial import ( | from mercurial import ( | ||||
| cmdutil, | cmdutil, | ||||
| commands, | commands, | ||||
| context, | context, | ||||
| copies as copiesmod, | copies as copiesmod, | ||||
| error, | error, | ||||
| obsutil, | obsutil, | ||||
| message = ctx.description() | message = ctx.description() | ||||
| if not user: | if not user: | ||||
| user = ctx.user() | user = ctx.user() | ||||
| if not date: | if not date: | ||||
| date = ctx.date() | date = ctx.date() | ||||
| new = context.memctx( | new = context.memctx( | ||||
| repo, | repo, | ||||
| parents=[base.node(), nullid], | parents=[base.node(), repo.nullid], | ||||
| text=message, | text=message, | ||||
| files=files, | files=files, | ||||
| filectxfn=filectxfn, | filectxfn=filectxfn, | ||||
| user=user, | user=user, | ||||
| date=date, | date=date, | ||||
| extra=ctx.extra(), | extra=ctx.extra(), | ||||
| ) | ) | ||||
| return repo.commitctx(new) | return repo.commitctx(new) | ||||
| import errno | import errno | ||||
| import struct | import struct | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| short, | short, | ||||
| wdirid, | |||||
| ) | ) | ||||
| from .pycompat import getattr | from .pycompat import getattr | ||||
| from . import ( | from . import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| obsutil, | obsutil, | ||||
| pycompat, | pycompat, | ||||
| scmutil, | scmutil, | ||||
| :bookmark-length: an unsigned short, | :bookmark-length: an unsigned short, | ||||
| :bookmark-name: the name of the bookmark (of length <bookmark-length>) | :bookmark-name: the name of the bookmark (of length <bookmark-length>) | ||||
| wdirid (all bits set) will be used as a special value for "missing" | wdirid (all bits set) will be used as a special value for "missing" | ||||
| """ | """ | ||||
| binarydata = [] | binarydata = [] | ||||
| for book, node in bookmarks: | for book, node in bookmarks: | ||||
| if not node: # None or '' | if not node: # None or '' | ||||
| node = wdirid | node = repo.nodeconstants.wdirid | ||||
| binarydata.append(_binaryentry.pack(node, len(book))) | binarydata.append(_binaryentry.pack(node, len(book))) | ||||
| binarydata.append(book) | binarydata.append(book) | ||||
| return b''.join(binarydata) | return b''.join(binarydata) | ||||
| def binarydecode(repo, stream): | def binarydecode(repo, stream): | ||||
| """decode a binary stream into an '(bookmark, node)' iterable | """decode a binary stream into an '(bookmark, node)' iterable | ||||
| if entry: | if entry: | ||||
| raise error.Abort(_(b'bad bookmark stream')) | raise error.Abort(_(b'bad bookmark stream')) | ||||
| break | break | ||||
| node, length = _binaryentry.unpack(entry) | node, length = _binaryentry.unpack(entry) | ||||
| bookmark = stream.read(length) | bookmark = stream.read(length) | ||||
| if len(bookmark) < length: | if len(bookmark) < length: | ||||
| if entry: | if entry: | ||||
| raise error.Abort(_(b'bad bookmark stream')) | raise error.Abort(_(b'bad bookmark stream')) | ||||
| if node == wdirid: | if node == repo.nodeconstants.wdirid: | ||||
| node = None | node = None | ||||
| books.append((bookmark, node)) | books.append((bookmark, node)) | ||||
| return books | return books | ||||
| def updatefromremote(ui, repo, remotemarks, path, trfunc, explicit=()): | def updatefromremote(ui, repo, remotemarks, path, trfunc, explicit=()): | ||||
| ui.debug(b"checking for updated bookmarks\n") | ui.debug(b"checking for updated bookmarks\n") | ||||
| localmarks = repo._bookmarks | localmarks = repo._bookmarks | ||||
| # branchmap.py - logic to computes, maintain and stores branchmap for local repo | # branchmap.py - logic to computes, maintain and stores branchmap for local repo | ||||
| # | # | ||||
| # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import struct | import struct | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| pycompat, | pycompat, | ||||
| scmutil, | scmutil, | ||||
| util, | util, | ||||
| This field can be used to avoid changelog reads when determining if a | This field can be used to avoid changelog reads when determining if a | ||||
| branch head closes a branch or not. | branch head closes a branch or not. | ||||
| """ | """ | ||||
| def __init__( | def __init__( | ||||
| self, | self, | ||||
| repo, | repo, | ||||
| entries=(), | entries=(), | ||||
| tipnode=nullid, | tipnode=None, | ||||
| tiprev=nullrev, | tiprev=nullrev, | ||||
| filteredhash=None, | filteredhash=None, | ||||
| closednodes=None, | closednodes=None, | ||||
| hasnode=None, | hasnode=None, | ||||
| ): | ): | ||||
| # type: (localrepo.localrepository, Union[Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]], bytes, int, Optional[bytes], Optional[Set[bytes]], Optional[Callable[[bytes], bool]]) -> None | # type: (localrepo.localrepository, Union[Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]], bytes, int, Optional[bytes], Optional[Set[bytes]], Optional[Callable[[bytes], bool]]) -> None | ||||
| """hasnode is a function which can be used to verify whether changelog | """hasnode is a function which can be used to verify whether changelog | ||||
| has a given node or not. If it's not provided, we assume that every node | has a given node or not. If it's not provided, we assume that every node | ||||
| we have exists in changelog""" | we have exists in changelog""" | ||||
| self._repo = repo | self._repo = repo | ||||
| if tipnode is None: | |||||
| self.tipnode = repo.nullid | |||||
| else: | |||||
| self.tipnode = tipnode | self.tipnode = tipnode | ||||
| self.tiprev = tiprev | self.tiprev = tiprev | ||||
| self.filteredhash = filteredhash | self.filteredhash = filteredhash | ||||
| # closednodes is a set of nodes that close their branch. If the branch | # closednodes is a set of nodes that close their branch. If the branch | ||||
| # cache has been updated, it may contain nodes that are no longer | # cache has been updated, it may contain nodes that are no longer | ||||
| # heads. | # heads. | ||||
| if closednodes is None: | if closednodes is None: | ||||
| self._closednodes = set() | self._closednodes = set() | ||||
| else: | else: | ||||
| ntiprev = tiprev | ntiprev = tiprev | ||||
| if ntiprev > self.tiprev: | if ntiprev > self.tiprev: | ||||
| self.tiprev = ntiprev | self.tiprev = ntiprev | ||||
| self.tipnode = cl.node(ntiprev) | self.tipnode = cl.node(ntiprev) | ||||
| if not self.validfor(repo): | if not self.validfor(repo): | ||||
| # cache key are not valid anymore | # cache key are not valid anymore | ||||
| self.tipnode = nullid | self.tipnode = repo.nullid | ||||
| self.tiprev = nullrev | self.tiprev = nullrev | ||||
| for heads in self.iterheads(): | for heads in self.iterheads(): | ||||
| tiprev = max(cl.rev(node) for node in heads) | tiprev = max(cl.rev(node) for node in heads) | ||||
| if tiprev > self.tiprev: | if tiprev > self.tiprev: | ||||
| self.tipnode = cl.node(tiprev) | self.tipnode = cl.node(tiprev) | ||||
| self.tiprev = tiprev | self.tiprev = tiprev | ||||
| self.filteredhash = scmutil.filteredhash(repo, self.tiprev) | self.filteredhash = scmutil.filteredhash(repo, self.tiprev) | ||||
| import re | import re | ||||
| import string | import string | ||||
| import struct | import struct | ||||
| import sys | import sys | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| short, | short, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| bookmarks, | bookmarks, | ||||
| changegroup, | changegroup, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| obsolete, | obsolete, | ||||
| packer = changegroup.getbundler( | packer = changegroup.getbundler( | ||||
| cgversion, | cgversion, | ||||
| repo, | repo, | ||||
| oldmatcher=oldmatcher, | oldmatcher=oldmatcher, | ||||
| matcher=newmatcher, | matcher=newmatcher, | ||||
| fullnodes=commonnodes, | fullnodes=commonnodes, | ||||
| ) | ) | ||||
| cgdata = packer.generate( | cgdata = packer.generate( | ||||
| {nullid}, | {repo.nullid}, | ||||
| list(commonnodes), | list(commonnodes), | ||||
| False, | False, | ||||
| b'narrow_widen', | b'narrow_widen', | ||||
| changelog=False, | changelog=False, | ||||
| ) | ) | ||||
| part = bundler.newpart(b'changegroup', data=cgdata) | part = bundler.newpart(b'changegroup', data=cgdata) | ||||
| part.addparam(b'version', cgversion) | part.addparam(b'version', cgversion) | ||||
| if scmutil.istreemanifest(repo): | if scmutil.istreemanifest(repo): | ||||
| part.addparam(b'treemanifest', b'1') | part.addparam(b'treemanifest', b'1') | ||||
| if b'exp-sidedata-flag' in repo.requirements: | if b'exp-sidedata-flag' in repo.requirements: | ||||
| part.addparam(b'exp-sidedata', b'1') | part.addparam(b'exp-sidedata', b'1') | ||||
| wanted = format_remote_wanted_sidedata(repo) | wanted = format_remote_wanted_sidedata(repo) | ||||
| part.addparam(b'exp-wanted-sidedata', wanted) | part.addparam(b'exp-wanted-sidedata', wanted) | ||||
| return bundler | return bundler | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import os | import os | ||||
| import shutil | import shutil | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| bundle2, | bundle2, | ||||
| changegroup, | changegroup, | ||||
| changelog, | changelog, | ||||
| cmdutil, | cmdutil, | ||||
| def peer(self): | def peer(self): | ||||
| return bundlepeer(self) | return bundlepeer(self) | ||||
| def getcwd(self): | def getcwd(self): | ||||
| return encoding.getcwd() # always outside the repo | return encoding.getcwd() # always outside the repo | ||||
| # Check if parents exist in localrepo before setting | # Check if parents exist in localrepo before setting | ||||
| def setparents(self, p1, p2=nullid): | def setparents(self, p1, p2=None): | ||||
| if p2 is None: | |||||
| p2 = self.nullid | |||||
| p1rev = self.changelog.rev(p1) | p1rev = self.changelog.rev(p1) | ||||
| p2rev = self.changelog.rev(p2) | p2rev = self.changelog.rev(p2) | ||||
| msg = _(b"setting parent to node %s that only exists in the bundle\n") | msg = _(b"setting parent to node %s that only exists in the bundle\n") | ||||
| if self.changelog.repotiprev < p1rev: | if self.changelog.repotiprev < p1rev: | ||||
| self.ui.warn(msg % hex(p1)) | self.ui.warn(msg % hex(p1)) | ||||
| if self.changelog.repotiprev < p2rev: | if self.changelog.repotiprev < p2rev: | ||||
| self.ui.warn(msg % hex(p2)) | self.ui.warn(msg % hex(p2)) | ||||
| return super(bundlerepository, self).setparents(p1, p2) | return super(bundlerepository, self).setparents(p1, p2) | ||||
| import collections | import collections | ||||
| import os | import os | ||||
| import struct | import struct | ||||
| import weakref | import weakref | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from .pycompat import open | from .pycompat import open | ||||
| from . import ( | from . import ( | ||||
| error, | error, | ||||
| match as matchmod, | match as matchmod, | ||||
| # The captured revision delta may be encoded as a delta against | # The captured revision delta may be encoded as a delta against | ||||
| # a base revision or as a full revision. The changegroup format | # a base revision or as a full revision. The changegroup format | ||||
| # requires that everything on the wire be deltas. So for full | # requires that everything on the wire be deltas. So for full | ||||
| # revisions, we need to invent a header that says to rewrite | # revisions, we need to invent a header that says to rewrite | ||||
| # data. | # data. | ||||
| if delta.delta is not None: | if delta.delta is not None: | ||||
| prefix, data = b'', delta.delta | prefix, data = b'', delta.delta | ||||
| elif delta.basenode == nullid: | elif delta.basenode == repo.nullid: | ||||
| data = delta.revision | data = delta.revision | ||||
| prefix = mdiff.trivialdiffheader(len(data)) | prefix = mdiff.trivialdiffheader(len(data)) | ||||
| else: | else: | ||||
| data = delta.revision | data = delta.revision | ||||
| prefix = mdiff.replacediffheader(delta.baserevisionsize, len(data)) | prefix = mdiff.replacediffheader(delta.baserevisionsize, len(data)) | ||||
| meta = headerfn(delta) | meta = headerfn(delta) | ||||
| # changelog.py - changelog class for mercurial | # changelog.py - changelog class for mercurial | ||||
| # | # | ||||
| # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| ) | ) | ||||
| from .thirdparty import attr | from .thirdparty import attr | ||||
| from . import ( | from . import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| metadata, | metadata, | ||||
| pycompat, | pycompat, | ||||
| '_text', | '_text', | ||||
| '_sidedata', | '_sidedata', | ||||
| '_cpsd', | '_cpsd', | ||||
| '_changes', | '_changes', | ||||
| ) | ) | ||||
| def __new__(cls, cl, text, sidedata, cpsd): | def __new__(cls, cl, text, sidedata, cpsd): | ||||
| if not text: | if not text: | ||||
| return _changelogrevision(extra=_defaultextra, manifest=nullid) | return _changelogrevision(extra=_defaultextra, manifest=cl.nullid) | ||||
| self = super(changelogrevision, cls).__new__(cls) | self = super(changelogrevision, cls).__new__(cls) | ||||
| # We could return here and implement the following as an __init__. | # We could return here and implement the following as an __init__. | ||||
| # But doing it here is equivalent and saves an extra function call. | # But doing it here is equivalent and saves an extra function call. | ||||
| # format used: | # format used: | ||||
| # nodeid\n : manifest node in ascii | # nodeid\n : manifest node in ascii | ||||
| # user\n : user, no \n or \r allowed | # user\n : user, no \n or \r allowed | ||||
| import copy as copymod | import copy as copymod | ||||
| import errno | import errno | ||||
| import os | import os | ||||
| import re | import re | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from .pycompat import ( | from .pycompat import ( | ||||
| getattr, | getattr, | ||||
| open, | open, | ||||
| setattr, | setattr, | ||||
| ) | ) | ||||
| """enforce the precondition that working directory must be clean. | """enforce the precondition that working directory must be clean. | ||||
| 'merge' can be set to false if a pending uncommitted merge should be | 'merge' can be set to false if a pending uncommitted merge should be | ||||
| ignored (such as when 'update --check' runs). | ignored (such as when 'update --check' runs). | ||||
| 'hint' is the usual hint given to Abort exception. | 'hint' is the usual hint given to Abort exception. | ||||
| """ | """ | ||||
| if merge and repo.dirstate.p2() != nullid: | if merge and repo.dirstate.p2() != repo.nullid: | ||||
| raise error.StateError(_(b'outstanding uncommitted merge'), hint=hint) | raise error.StateError(_(b'outstanding uncommitted merge'), hint=hint) | ||||
| st = repo.status() | st = repo.status() | ||||
| if st.modified or st.added or st.removed or st.deleted: | if st.modified or st.added or st.removed or st.deleted: | ||||
| raise error.StateError(_(b'uncommitted changes'), hint=hint) | raise error.StateError(_(b'uncommitted changes'), hint=hint) | ||||
| ctx = repo[None] | ctx = repo[None] | ||||
| for s in sorted(ctx.substate): | for s in sorted(ctx.substate): | ||||
| ctx.sub(s).bailifchanged(hint=hint) | ctx.sub(s).bailifchanged(hint=hint) | ||||
| parents = [p.node() for p in ctx.parents() if p] | parents = [p.node() for p in ctx.parents() if p] | ||||
| branch = ctx.branch() | branch = ctx.branch() | ||||
| if switch_parent: | if switch_parent: | ||||
| parents.reverse() | parents.reverse() | ||||
| if parents: | if parents: | ||||
| prev = parents[0] | prev = parents[0] | ||||
| else: | else: | ||||
| prev = nullid | prev = repo.nullid | ||||
| fm.context(ctx=ctx) | fm.context(ctx=ctx) | ||||
| fm.plain(b'# HG changeset patch\n') | fm.plain(b'# HG changeset patch\n') | ||||
| fm.write(b'user', b'# User %s\n', ctx.user()) | fm.write(b'user', b'# User %s\n', ctx.user()) | ||||
| fm.plain(b'# Date %d %d\n' % ctx.date()) | fm.plain(b'# Date %d %d\n' % ctx.date()) | ||||
| fm.write(b'date', b'# %s\n', fm.formatdate(ctx.date())) | fm.write(b'date', b'# %s\n', fm.formatdate(ctx.date())) | ||||
| fm.condwrite( | fm.condwrite( | ||||
| branch and branch != b'default', b'branch', b'# Branch %s\n', branch | branch and branch != b'default', b'branch', b'# Branch %s\n', branch | ||||
| commitphase = None | commitphase = None | ||||
| if opts.get(b'secret'): | if opts.get(b'secret'): | ||||
| commitphase = phases.secret | commitphase = phases.secret | ||||
| newid = repo.commitctx(new) | newid = repo.commitctx(new) | ||||
| ms.reset() | ms.reset() | ||||
| # Reroute the working copy parent to the new changeset | # Reroute the working copy parent to the new changeset | ||||
| repo.setparents(newid, nullid) | repo.setparents(newid, repo.nullid) | ||||
| # Fixing the dirstate because localrepo.commitctx does not update | # Fixing the dirstate because localrepo.commitctx does not update | ||||
| # it. This is rather convenient because we did not need to update | # it. This is rather convenient because we did not need to update | ||||
| # the dirstate for all the files in the new commit which commitctx | # the dirstate for all the files in the new commit which commitctx | ||||
| # could have done if it updated the dirstate. Now, we can | # could have done if it updated the dirstate. Now, we can | ||||
| # selectively update the dirstate only for the amended files. | # selectively update the dirstate only for the amended files. | ||||
| dirstate = repo.dirstate | dirstate = repo.dirstate | ||||
| # We need to wait for some post-processing to update this set | # We need to wait for some post-processing to update this set | ||||
| # before making the distinction. The dirstate will be used for | # before making the distinction. The dirstate will be used for | ||||
| # that purpose. | # that purpose. | ||||
| dsadded = added | dsadded = added | ||||
| # in case of merge, files that are actually added can be reported as | # in case of merge, files that are actually added can be reported as | ||||
| # modified, we need to post process the result | # modified, we need to post process the result | ||||
| if p2 != nullid: | if p2 != repo.nullid: | ||||
| mergeadd = set(dsmodified) | mergeadd = set(dsmodified) | ||||
| for path in dsmodified: | for path in dsmodified: | ||||
| if path in mf: | if path in mf: | ||||
| mergeadd.remove(path) | mergeadd.remove(path) | ||||
| dsadded |= mergeadd | dsadded |= mergeadd | ||||
| dsmodified -= mergeadd | dsmodified -= mergeadd | ||||
| # if f is a rename, update `names` to also revert the source | # if f is a rename, update `names` to also revert the source | ||||
| prntstatusmsg(b'drop', f) | prntstatusmsg(b'drop', f) | ||||
| repo.dirstate.remove(f) | repo.dirstate.remove(f) | ||||
| normal = None | normal = None | ||||
| if node == parent: | if node == parent: | ||||
| # We're reverting to our parent. If possible, we'd like status | # We're reverting to our parent. If possible, we'd like status | ||||
| # to report the file as clean. We have to use normallookup for | # to report the file as clean. We have to use normallookup for | ||||
| # merges to avoid losing information about merged/dirty files. | # merges to avoid losing information about merged/dirty files. | ||||
| if p2 != nullid: | if p2 != repo.nullid: | ||||
| normal = repo.dirstate.normallookup | normal = repo.dirstate.normallookup | ||||
| else: | else: | ||||
| normal = repo.dirstate.normal | normal = repo.dirstate.normal | ||||
| newlyaddedandmodifiedfiles = set() | newlyaddedandmodifiedfiles = set() | ||||
| if interactive: | if interactive: | ||||
| # Prompt the user for changes to revert | # Prompt the user for changes to revert | ||||
| torevert = [f for f in actions[b'revert'][0] if f not in excluded_files] | torevert = [f for f in actions[b'revert'][0] if f not in excluded_files] | ||||
| for f in actions[b'add'][0]: | for f in actions[b'add'][0]: | ||||
| # Don't checkout modified files, they are already created by the diff | # Don't checkout modified files, they are already created by the diff | ||||
| if f not in newlyaddedandmodifiedfiles: | if f not in newlyaddedandmodifiedfiles: | ||||
| prntstatusmsg(b'add', f) | prntstatusmsg(b'add', f) | ||||
| checkout(f) | checkout(f) | ||||
| repo.dirstate.add(f) | repo.dirstate.add(f) | ||||
| normal = repo.dirstate.normallookup | normal = repo.dirstate.normallookup | ||||
| if node == parent and p2 == nullid: | if node == parent and p2 == repo.nullid: | ||||
| normal = repo.dirstate.normal | normal = repo.dirstate.normal | ||||
| for f in actions[b'undelete'][0]: | for f in actions[b'undelete'][0]: | ||||
| if interactive: | if interactive: | ||||
| choice = repo.ui.promptchoice( | choice = repo.ui.promptchoice( | ||||
| _(b"add back removed file %s (Yn)?$$ &Yes $$ &No") % f | _(b"add back removed file %s (Yn)?$$ &Yes $$ &No") % f | ||||
| ) | ) | ||||
| if choice == 0: | if choice == 0: | ||||
| prntstatusmsg(b'undelete', f) | prntstatusmsg(b'undelete', f) | ||||
| import errno | import errno | ||||
| import os | import os | ||||
| import re | import re | ||||
| import sys | import sys | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| wdirhex, | |||||
| wdirrev, | wdirrev, | ||||
| ) | ) | ||||
| from .pycompat import open | from .pycompat import open | ||||
| from . import ( | from . import ( | ||||
| archival, | archival, | ||||
| bookmarks, | bookmarks, | ||||
| bundle2, | bundle2, | ||||
| bundlecaches, | bundlecaches, | ||||
| def formatrev(rev): | def formatrev(rev): | ||||
| if rev == wdirrev: | if rev == wdirrev: | ||||
| return b'%d+' % ctx.p1().rev() | return b'%d+' % ctx.p1().rev() | ||||
| else: | else: | ||||
| return b'%d ' % rev | return b'%d ' % rev | ||||
| def formathex(h): | def formathex(h): | ||||
| if h == wdirhex: | if h == repo.nodeconstants.wdirhex: | ||||
| return b'%s+' % shorthex(hex(ctx.p1().node())) | return b'%s+' % shorthex(hex(ctx.p1().node())) | ||||
| else: | else: | ||||
| return b'%s ' % shorthex(h) | return b'%s ' % shorthex(h) | ||||
| else: | else: | ||||
| formatrev = b'%d'.__mod__ | formatrev = b'%d'.__mod__ | ||||
| formathex = shorthex | formathex = shorthex | ||||
| op1, op2 = repo.dirstate.parents() | op1, op2 = repo.dirstate.parents() | ||||
| if not repo.changelog.isancestor(node, op1): | if not repo.changelog.isancestor(node, op1): | ||||
| raise error.InputError( | raise error.InputError( | ||||
| _(b'cannot backout change that is not an ancestor') | _(b'cannot backout change that is not an ancestor') | ||||
| ) | ) | ||||
| p1, p2 = repo.changelog.parents(node) | p1, p2 = repo.changelog.parents(node) | ||||
| if p1 == nullid: | if p1 == repo.nullid: | ||||
| raise error.InputError(_(b'cannot backout a change with no parents')) | raise error.InputError(_(b'cannot backout a change with no parents')) | ||||
| if p2 != nullid: | if p2 != repo.nullid: | ||||
| if not opts.get(b'parent'): | if not opts.get(b'parent'): | ||||
| raise error.InputError(_(b'cannot backout a merge changeset')) | raise error.InputError(_(b'cannot backout a merge changeset')) | ||||
| p = repo.lookup(opts[b'parent']) | p = repo.lookup(opts[b'parent']) | ||||
| if p not in (p1, p2): | if p not in (p1, p2): | ||||
| raise error.InputError( | raise error.InputError( | ||||
| _(b'%s is not a parent of %s') % (short(p), short(node)) | _(b'%s is not a parent of %s') % (short(p), short(node)) | ||||
| ) | ) | ||||
| parent = p | parent = p | ||||
| raise error.StateError( | raise error.StateError( | ||||
| _( | _( | ||||
| b'current bisect revision is unknown - ' | b'current bisect revision is unknown - ' | ||||
| b'start a new bisect to fix' | b'start a new bisect to fix' | ||||
| ) | ) | ||||
| ) | ) | ||||
| else: | else: | ||||
| node, p2 = repo.dirstate.parents() | node, p2 = repo.dirstate.parents() | ||||
| if p2 != nullid: | if p2 != repo.nullid: | ||||
| raise error.StateError(_(b'current bisect revision is a merge')) | raise error.StateError(_(b'current bisect revision is a merge')) | ||||
| if rev: | if rev: | ||||
| if not nodes: | if not nodes: | ||||
| raise error.Abort(_(b'empty revision set')) | raise error.Abort(_(b'empty revision set')) | ||||
| node = repo[nodes[-1]].node() | node = repo[nodes[-1]].node() | ||||
| with hbisect.restore_state(repo, state, node): | with hbisect.restore_state(repo, state, node): | ||||
| while changesets: | while changesets: | ||||
| # update state | # update state | ||||
| will check out a clean copy of the original merge parent, losing | will check out a clean copy of the original merge parent, losing | ||||
| all changes. | all changes. | ||||
| Returns 0 on success, 1 if there are unresolved files. | Returns 0 on success, 1 if there are unresolved files. | ||||
| """ | """ | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| abort = opts.get(b'abort') | abort = opts.get(b'abort') | ||||
| if abort and repo.dirstate.p2() == nullid: | if abort and repo.dirstate.p2() == repo.nullid: | ||||
| cmdutil.wrongtooltocontinue(repo, _(b'merge')) | cmdutil.wrongtooltocontinue(repo, _(b'merge')) | ||||
| cmdutil.check_incompatible_arguments(opts, b'abort', [b'rev', b'preview']) | cmdutil.check_incompatible_arguments(opts, b'abort', [b'rev', b'preview']) | ||||
| if abort: | if abort: | ||||
| state = cmdutil.getunfinishedstate(repo) | state = cmdutil.getunfinishedstate(repo) | ||||
| if state and state._opname != b'merge': | if state and state._opname != b'merge': | ||||
| raise error.StateError( | raise error.StateError( | ||||
| _(b'cannot abort merge with %s in progress') % (state._opname), | _(b'cannot abort merge with %s in progress') % (state._opname), | ||||
| hint=state.hint(), | hint=state.hint(), | ||||
| for fn in filenodes: | for fn in filenodes: | ||||
| fctx = repo.filectx(file_, fileid=fn) | fctx = repo.filectx(file_, fileid=fn) | ||||
| p.append(fctx.node()) | p.append(fctx.node()) | ||||
| else: | else: | ||||
| p = [cp.node() for cp in ctx.parents()] | p = [cp.node() for cp in ctx.parents()] | ||||
| displayer = logcmdutil.changesetdisplayer(ui, repo, opts) | displayer = logcmdutil.changesetdisplayer(ui, repo, opts) | ||||
| for n in p: | for n in p: | ||||
| if n != nullid: | if n != repo.nullid: | ||||
| displayer.show(repo[n]) | displayer.show(repo[n]) | ||||
| displayer.close() | displayer.close() | ||||
| @command( | @command( | ||||
| b'paths', | b'paths', | ||||
| formatteropts, | formatteropts, | ||||
| _(b'[NAME]'), | _(b'[NAME]'), | ||||
| fm.data(path=f) | fm.data(path=f) | ||||
| fm.plain(b'%s\n' % uipathfn(f), label=label) | fm.plain(b'%s\n' % uipathfn(f), label=label) | ||||
| fm.end() | fm.end() | ||||
| return 0 | return 0 | ||||
| with repo.wlock(): | with repo.wlock(): | ||||
| ms = mergestatemod.mergestate.read(repo) | ms = mergestatemod.mergestate.read(repo) | ||||
| if not (ms.active() or repo.dirstate.p2() != nullid): | if not (ms.active() or repo.dirstate.p2() != repo.nullid): | ||||
| raise error.StateError( | raise error.StateError( | ||||
| _(b'resolve command not applicable when not merging') | _(b'resolve command not applicable when not merging') | ||||
| ) | ) | ||||
| wctx = repo[None] | wctx = repo[None] | ||||
| m = scmutil.match(wctx, pats, opts) | m = scmutil.match(wctx, pats, opts) | ||||
| ret = 0 | ret = 0 | ||||
| didwork = False | didwork = False | ||||
| a = repo.wjoin(f) | a = repo.wjoin(f) | ||||
| try: | try: | ||||
| util.rename(a + b".resolve", scmutil.backuppath(ui, repo, f)) | util.rename(a + b".resolve", scmutil.backuppath(ui, repo, f)) | ||||
| except OSError as inst: | except OSError as inst: | ||||
| if inst.errno != errno.ENOENT: | if inst.errno != errno.ENOENT: | ||||
| raise | raise | ||||
| ms.commit() | ms.commit() | ||||
| branchmerge = repo.dirstate.p2() != nullid | branchmerge = repo.dirstate.p2() != repo.nullid | ||||
| mergestatemod.recordupdates(repo, ms.actions(), branchmerge, None) | mergestatemod.recordupdates(repo, ms.actions(), branchmerge, None) | ||||
| if not didwork and pats: | if not didwork and pats: | ||||
| hint = None | hint = None | ||||
| if not any([p for p in pats if p.find(b':') >= 0]): | if not any([p for p in pats if p.find(b':') >= 0]): | ||||
| pats = [b'path:%s' % p for p in pats] | pats = [b'path:%s' % p for p in pats] | ||||
| m = scmutil.match(wctx, pats, opts) | m = scmutil.match(wctx, pats, opts) | ||||
| for f in ms: | for f in ms: | ||||
| """ | """ | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| if opts.get(b"date"): | if opts.get(b"date"): | ||||
| cmdutil.check_incompatible_arguments(opts, b'date', [b'rev']) | cmdutil.check_incompatible_arguments(opts, b'date', [b'rev']) | ||||
| opts[b"rev"] = cmdutil.finddate(ui, repo, opts[b"date"]) | opts[b"rev"] = cmdutil.finddate(ui, repo, opts[b"date"]) | ||||
| parent, p2 = repo.dirstate.parents() | parent, p2 = repo.dirstate.parents() | ||||
| if not opts.get(b'rev') and p2 != nullid: | if not opts.get(b'rev') and p2 != repo.nullid: | ||||
| # revert after merge is a trap for new users (issue2915) | # revert after merge is a trap for new users (issue2915) | ||||
| raise error.InputError( | raise error.InputError( | ||||
| _(b'uncommitted merge with no revision specified'), | _(b'uncommitted merge with no revision specified'), | ||||
| hint=_(b"use 'hg update' or see 'hg help revert'"), | hint=_(b"use 'hg update' or see 'hg help revert'"), | ||||
| ) | ) | ||||
| rev = opts.get(b'rev') | rev = opts.get(b'rev') | ||||
| if rev: | if rev: | ||||
| repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn') | repo = scmutil.unhidehashlikerevs(repo, [rev], b'nowarn') | ||||
| ctx = scmutil.revsingle(repo, rev) | ctx = scmutil.revsingle(repo, rev) | ||||
| if not ( | if not ( | ||||
| pats | pats | ||||
| or opts.get(b'include') | or opts.get(b'include') | ||||
| or opts.get(b'exclude') | or opts.get(b'exclude') | ||||
| or opts.get(b'all') | or opts.get(b'all') | ||||
| or opts.get(b'interactive') | or opts.get(b'interactive') | ||||
| ): | ): | ||||
| msg = _(b"no files or directories specified") | msg = _(b"no files or directories specified") | ||||
| if p2 != nullid: | if p2 != repo.nullid: | ||||
| hint = _( | hint = _( | ||||
| b"uncommitted merge, use --all to discard all changes," | b"uncommitted merge, use --all to discard all changes," | ||||
| b" or 'hg update -C .' to abort the merge" | b" or 'hg update -C .' to abort the merge" | ||||
| ) | ) | ||||
| raise error.InputError(msg, hint=hint) | raise error.InputError(msg, hint=hint) | ||||
| dirty = any(repo.status()) | dirty = any(repo.status()) | ||||
| node = ctx.node() | node = ctx.node() | ||||
| if node != parent: | if node != parent: | ||||
| if opts.get(b'local'): | if opts.get(b'local'): | ||||
| expectedtype = b'local' | expectedtype = b'local' | ||||
| else: | else: | ||||
| expectedtype = b'global' | expectedtype = b'global' | ||||
| for n in names: | for n in names: | ||||
| if repo.tagtype(n) == b'global': | if repo.tagtype(n) == b'global': | ||||
| alltags = tagsmod.findglobaltags(ui, repo) | alltags = tagsmod.findglobaltags(ui, repo) | ||||
| if alltags[n][0] == nullid: | if alltags[n][0] == repo.nullid: | ||||
| raise error.InputError( | raise error.InputError( | ||||
| _(b"tag '%s' is already removed") % n | _(b"tag '%s' is already removed") % n | ||||
| ) | ) | ||||
| if not repo.tagtype(n): | if not repo.tagtype(n): | ||||
| raise error.InputError(_(b"tag '%s' does not exist") % n) | raise error.InputError(_(b"tag '%s' does not exist") % n) | ||||
| if repo.tagtype(n) != expectedtype: | if repo.tagtype(n) != expectedtype: | ||||
| if expectedtype == b'global': | if expectedtype == b'global': | ||||
| raise error.InputError( | raise error.InputError( | ||||
| elif not opts.get(b'force'): | elif not opts.get(b'force'): | ||||
| for n in names: | for n in names: | ||||
| if n in repo.tags(): | if n in repo.tags(): | ||||
| raise error.InputError( | raise error.InputError( | ||||
| _(b"tag '%s' already exists (use -f to force)") % n | _(b"tag '%s' already exists (use -f to force)") % n | ||||
| ) | ) | ||||
| if not opts.get(b'local'): | if not opts.get(b'local'): | ||||
| p1, p2 = repo.dirstate.parents() | p1, p2 = repo.dirstate.parents() | ||||
| if p2 != nullid: | if p2 != repo.nullid: | ||||
| raise error.StateError(_(b'uncommitted merge')) | raise error.StateError(_(b'uncommitted merge')) | ||||
| bheads = repo.branchheads() | bheads = repo.branchheads() | ||||
| if not opts.get(b'force') and bheads and p1 not in bheads: | if not opts.get(b'force') and bheads and p1 not in bheads: | ||||
| raise error.InputError( | raise error.InputError( | ||||
| _( | _( | ||||
| b'working directory is not at a branch head ' | b'working directory is not at a branch head ' | ||||
| b'(use -f to force)' | b'(use -f to force)' | ||||
| ) | ) | ||||
| # commit.py - fonction to perform commit | # commit.py - fonction to perform commit | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import errno | import errno | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| context, | context, | ||||
| mergestate, | mergestate, | ||||
| metadata, | metadata, | ||||
| phases, | phases, | ||||
| output: (filenode, touched) | output: (filenode, touched) | ||||
| filenode: the filenode that should be used by this changeset | filenode: the filenode that should be used by this changeset | ||||
| touched: one of: None (mean untouched), 'added' or 'modified' | touched: one of: None (mean untouched), 'added' or 'modified' | ||||
| """ | """ | ||||
| fname = fctx.path() | fname = fctx.path() | ||||
| fparent1 = manifest1.get(fname, nullid) | fparent1 = manifest1.get(fname, repo.nullid) | ||||
| fparent2 = manifest2.get(fname, nullid) | fparent2 = manifest2.get(fname, repo.nullid) | ||||
| touched = None | touched = None | ||||
| if fparent1 == fparent2 == nullid: | if fparent1 == fparent2 == repo.nullid: | ||||
| touched = 'added' | touched = 'added' | ||||
| if isinstance(fctx, context.filectx): | if isinstance(fctx, context.filectx): | ||||
| # This block fast path most comparisons which are usually done. It | # This block fast path most comparisons which are usually done. It | ||||
| # assumes that bare filectx is used and no merge happened, hence no | # assumes that bare filectx is used and no merge happened, hence no | ||||
| # need to create a new file revision in this case. | # need to create a new file revision in this case. | ||||
| node = fctx.filenode() | node = fctx.filenode() | ||||
| if node in [fparent1, fparent2]: | if node in [fparent1, fparent2]: | ||||
| repo.ui.debug(b'reusing %s filelog entry\n' % fname) | repo.ui.debug(b'reusing %s filelog entry\n' % fname) | ||||
| if ( | if ( | ||||
| fparent1 != nullid and manifest1.flags(fname) != fctx.flags() | fparent1 != repo.nullid | ||||
| and manifest1.flags(fname) != fctx.flags() | |||||
| ) or ( | ) or ( | ||||
| fparent2 != nullid and manifest2.flags(fname) != fctx.flags() | fparent2 != repo.nullid | ||||
| and manifest2.flags(fname) != fctx.flags() | |||||
| ): | ): | ||||
| touched = 'modified' | touched = 'modified' | ||||
| return node, touched | return node, touched | ||||
| flog = repo.file(fname) | flog = repo.file(fname) | ||||
| meta = {} | meta = {} | ||||
| cfname = fctx.copysource() | cfname = fctx.copysource() | ||||
| fnode = None | fnode = None | ||||
| # \ / merging rev3 and rev4 should use bar@rev2 | # \ / merging rev3 and rev4 should use bar@rev2 | ||||
| # \- 2 --- 4 as the merge base | # \- 2 --- 4 as the merge base | ||||
| # | # | ||||
| cnode = manifest1.get(cfname) | cnode = manifest1.get(cfname) | ||||
| newfparent = fparent2 | newfparent = fparent2 | ||||
| if manifest2: # branch merge | if manifest2: # branch merge | ||||
| if fparent2 == nullid or cnode is None: # copied on remote side | if ( | ||||
| fparent2 == repo.nullid or cnode is None | |||||
| ): # copied on remote side | |||||
| if cfname in manifest2: | if cfname in manifest2: | ||||
| cnode = manifest2[cfname] | cnode = manifest2[cfname] | ||||
| newfparent = fparent1 | newfparent = fparent1 | ||||
| # Here, we used to search backwards through history to try to find | # 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 | # 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 | # the parent directory. However, this doesn't actually make sense to | ||||
| # do (what does a copy from something not in your working copy even | # do (what does a copy from something not in your working copy even | ||||
| # mean?) and it causes bugs (eg, issue4476). Instead, we will warn | # mean?) and it causes bugs (eg, issue4476). Instead, we will warn | ||||
| # the user that copy information was dropped, so if they didn't | # the user that copy information was dropped, so if they didn't | ||||
| # expect this outcome it can be fixed, but this is the correct | # expect this outcome it can be fixed, but this is the correct | ||||
| # behavior in this circumstance. | # behavior in this circumstance. | ||||
| if cnode: | if cnode: | ||||
| repo.ui.debug(b" %s: copy %s:%s\n" % (fname, cfname, hex(cnode))) | repo.ui.debug(b" %s: copy %s:%s\n" % (fname, cfname, hex(cnode))) | ||||
| if includecopymeta: | if includecopymeta: | ||||
| meta[b"copy"] = cfname | meta[b"copy"] = cfname | ||||
| meta[b"copyrev"] = hex(cnode) | meta[b"copyrev"] = hex(cnode) | ||||
| fparent1, fparent2 = nullid, newfparent | fparent1, fparent2 = repo.nullid, newfparent | ||||
| else: | else: | ||||
| repo.ui.warn( | repo.ui.warn( | ||||
| _( | _( | ||||
| b"warning: can't find ancestor for '%s' " | b"warning: can't find ancestor for '%s' " | ||||
| b"copied from '%s'!\n" | b"copied from '%s'!\n" | ||||
| ) | ) | ||||
| % (fname, cfname) | % (fname, cfname) | ||||
| ) | ) | ||||
| elif fparent1 == nullid: | elif fparent1 == repo.nullid: | ||||
| fparent1, fparent2 = fparent2, nullid | fparent1, fparent2 = fparent2, repo.nullid | ||||
| elif fparent2 != nullid: | elif fparent2 != repo.nullid: | ||||
| if ms.active() and ms.extras(fname).get(b'filenode-source') == b'other': | if ms.active() and ms.extras(fname).get(b'filenode-source') == b'other': | ||||
| fparent1, fparent2 = fparent2, nullid | fparent1, fparent2 = fparent2, repo.nullid | ||||
| elif ms.active() and ms.extras(fname).get(b'merged') != b'yes': | elif ms.active() and ms.extras(fname).get(b'merged') != b'yes': | ||||
| fparent1, fparent2 = fparent1, nullid | fparent1, fparent2 = fparent1, repo.nullid | ||||
| # is one parent an ancestor of the other? | # is one parent an ancestor of the other? | ||||
| else: | else: | ||||
| fparentancestors = flog.commonancestorsheads(fparent1, fparent2) | fparentancestors = flog.commonancestorsheads(fparent1, fparent2) | ||||
| if fparent1 in fparentancestors: | if fparent1 in fparentancestors: | ||||
| fparent1, fparent2 = fparent2, nullid | fparent1, fparent2 = fparent2, repo.nullid | ||||
| elif fparent2 in fparentancestors: | elif fparent2 in fparentancestors: | ||||
| fparent2 = nullid | fparent2 = repo.nullid | ||||
| force_new_node = False | force_new_node = False | ||||
| # The file might have been deleted by merge code and user explicitly choose | # The file might have been deleted by merge code and user explicitly choose | ||||
| # to revert the file and keep it. The other case can be where there is | # to revert the file and keep it. The other case can be where there is | ||||
| # change-delete or delete-change conflict and user explicitly choose to keep | # change-delete or delete-change conflict and user explicitly choose to keep | ||||
| # the file. The goal is to create a new filenode for users explicit choices | # the file. The goal is to create a new filenode for users explicit choices | ||||
| if ( | if ( | ||||
| repo.ui.configbool(b'experimental', b'merge-track-salvaged') | repo.ui.configbool(b'experimental', b'merge-track-salvaged') | ||||
| and ms.active() | and ms.active() | ||||
| and ms.extras(fname).get(b'merge-removal-candidate') == b'yes' | and ms.extras(fname).get(b'merge-removal-candidate') == b'yes' | ||||
| ): | ): | ||||
| force_new_node = True | force_new_node = True | ||||
| # is the file changed? | # is the file changed? | ||||
| text = fctx.data() | text = fctx.data() | ||||
| if fparent2 != nullid or meta or flog.cmp(fparent1, text) or force_new_node: | if ( | ||||
| fparent2 != repo.nullid | |||||
| or meta | |||||
| or flog.cmp(fparent1, text) | |||||
| or force_new_node | |||||
| ): | |||||
| if touched is None: # do not overwrite added | if touched is None: # do not overwrite added | ||||
| if fparent2 == nullid: | if fparent2 == repo.nullid: | ||||
| touched = 'modified' | touched = 'modified' | ||||
| else: | else: | ||||
| touched = 'merged' | touched = 'merged' | ||||
| fnode = flog.add(text, meta, tr, linkrev, fparent1, fparent2) | fnode = flog.add(text, meta, tr, linkrev, fparent1, fparent2) | ||||
| # are just the flags changed during merge? | # are just the flags changed during merge? | ||||
| elif fname in manifest1 and manifest1.flags(fname) != fctx.flags(): | elif fname in manifest1 and manifest1.flags(fname) != fctx.flags(): | ||||
| touched = 'modified' | touched = 'modified' | ||||
| fnode = fparent1 | fnode = fparent1 | ||||
| # context.py - changeset and file context objects for mercurial | # context.py - changeset and file context objects for mercurial | ||||
| # | # | ||||
| # Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import errno | import errno | ||||
| import filecmp | import filecmp | ||||
| import os | import os | ||||
| import stat | import stat | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| addednodeid, | |||||
| hex, | hex, | ||||
| modifiednodeid, | |||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| wdirfilenodeids, | |||||
| wdirhex, | |||||
| ) | ) | ||||
| from .pycompat import ( | from .pycompat import ( | ||||
| getattr, | getattr, | ||||
| open, | open, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| dagop, | dagop, | ||||
| encoding, | encoding, | ||||
| continue | continue | ||||
| (node1, flag1), (node2, flag2) = value | (node1, flag1), (node2, flag2) = value | ||||
| if node1 is None: | if node1 is None: | ||||
| added.append(fn) | added.append(fn) | ||||
| elif node2 is None: | elif node2 is None: | ||||
| removed.append(fn) | removed.append(fn) | ||||
| elif flag1 != flag2: | elif flag1 != flag2: | ||||
| modified.append(fn) | modified.append(fn) | ||||
| elif node2 not in wdirfilenodeids: | elif node2 not in self._repo.nodeconstants.wdirfilenodeids: | ||||
| # When comparing files between two commits, we save time by | # When comparing files between two commits, we save time by | ||||
| # not comparing the file contents when the nodeids differ. | # not comparing the file contents when the nodeids differ. | ||||
| # Note that this means we incorrectly report a reverted change | # Note that this means we incorrectly report a reverted change | ||||
| # to a file as a modification. | # to a file as a modification. | ||||
| modified.append(fn) | modified.append(fn) | ||||
| elif self[fn].cmp(other[fn]): | elif self[fn].cmp(other[fn]): | ||||
| modified.append(fn) | modified.append(fn) | ||||
| else: | else: | ||||
| merge.preferancestor configuration before falling back to the | merge.preferancestor configuration before falling back to the | ||||
| revlog ancestor.""" | revlog ancestor.""" | ||||
| # deal with workingctxs | # deal with workingctxs | ||||
| n2 = c2._node | n2 = c2._node | ||||
| if n2 is None: | if n2 is None: | ||||
| n2 = c2._parents[0]._node | n2 = c2._parents[0]._node | ||||
| cahs = self._repo.changelog.commonancestorsheads(self._node, n2) | cahs = self._repo.changelog.commonancestorsheads(self._node, n2) | ||||
| if not cahs: | if not cahs: | ||||
| anc = nullid | anc = self._repo.nodeconstants.nullid | ||||
| elif len(cahs) == 1: | elif len(cahs) == 1: | ||||
| anc = cahs[0] | anc = cahs[0] | ||||
| else: | else: | ||||
| # experimental config: merge.preferancestor | # experimental config: merge.preferancestor | ||||
| for r in self._repo.ui.configlist(b'merge', b'preferancestor'): | for r in self._repo.ui.configlist(b'merge', b'preferancestor'): | ||||
| try: | try: | ||||
| ctx = scmutil.revsymbol(self._repo, r) | ctx = scmutil.revsymbol(self._repo, r) | ||||
| except error.RepoLookupError: | except error.RepoLookupError: | ||||
| fctx._descendantrev = self._descendantrev | fctx._descendantrev = self._descendantrev | ||||
| fctx._ancestrycontext = getattr(self, '_ancestrycontext', None) | fctx._ancestrycontext = getattr(self, '_ancestrycontext', None) | ||||
| return fctx | return fctx | ||||
| def parents(self): | def parents(self): | ||||
| _path = self._path | _path = self._path | ||||
| fl = self._filelog | fl = self._filelog | ||||
| parents = self._filelog.parents(self._filenode) | parents = self._filelog.parents(self._filenode) | ||||
| pl = [(_path, node, fl) for node in parents if node != nullid] | pl = [ | ||||
| (_path, node, fl) | |||||
| for node in parents | |||||
| if node != self._repo.nodeconstants.nullid | |||||
| ] | |||||
| r = fl.renamed(self._filenode) | r = fl.renamed(self._filenode) | ||||
| if r: | if r: | ||||
| # - In the simple rename case, both parent are nullid, pl is empty. | # - In the simple rename case, both parent are nullid, pl is empty. | ||||
| # - In case of merge, only one of the parent is null id and should | # - In case of merge, only one of the parent is null id and should | ||||
| # be replaced with the rename information. This parent is -always- | # be replaced with the rename information. This parent is -always- | ||||
| # the first one. | # the first one. | ||||
| # | # | ||||
| for f in d: | for f in d: | ||||
| if d[f] != b'r': | if d[f] != b'r': | ||||
| yield f | yield f | ||||
| def __contains__(self, key): | def __contains__(self, key): | ||||
| return self._repo.dirstate[key] not in b"?r" | return self._repo.dirstate[key] not in b"?r" | ||||
| def hex(self): | def hex(self): | ||||
| return wdirhex | return self._repo.nodeconstants.wdirhex | ||||
| @propertycache | @propertycache | ||||
| def _parents(self): | def _parents(self): | ||||
| p = self._repo.dirstate.parents() | p = self._repo.dirstate.parents() | ||||
| if p[1] == nullid: | if p[1] == self._repo.nodeconstants.nullid: | ||||
| p = p[:-1] | p = p[:-1] | ||||
| # use unfiltered repo to delay/avoid loading obsmarkers | # use unfiltered repo to delay/avoid loading obsmarkers | ||||
| unfi = self._repo.unfiltered() | unfi = self._repo.unfiltered() | ||||
| return [ | return [ | ||||
| changectx( | changectx( | ||||
| self._repo, unfi.changelog.rev(n), n, maybe_filtered=False | self._repo, unfi.changelog.rev(n), n, maybe_filtered=False | ||||
| ) | ) | ||||
| for n in p | for n in p | ||||
| ] | ] | ||||
| def setparents(self, p1node, p2node=nullid): | def setparents(self, p1node, p2node=None): | ||||
| if p2node is None: | |||||
| p2node = self._repo.nodeconstants.nullid | |||||
| dirstate = self._repo.dirstate | dirstate = self._repo.dirstate | ||||
| with dirstate.parentchange(): | with dirstate.parentchange(): | ||||
| copies = dirstate.setparents(p1node, p2node) | copies = dirstate.setparents(p1node, p2node) | ||||
| pctx = self._repo[p1node] | pctx = self._repo[p1node] | ||||
| if copies: | if copies: | ||||
| # Adjust copy records, the dirstate cannot do it, it | # Adjust copy records, the dirstate cannot do it, it | ||||
| # requires access to parents manifests. Preserve them | # requires access to parents manifests. Preserve them | ||||
| # only for entries added to first parent. | # only for entries added to first parent. | ||||
| for f in copies: | for f in copies: | ||||
| if f not in pctx and copies[f] in pctx: | if f not in pctx and copies[f] in pctx: | ||||
| dirstate.copy(copies[f], f) | dirstate.copy(copies[f], f) | ||||
| if p2node == nullid: | if p2node == self._repo.nodeconstants.nullid: | ||||
| for f, s in sorted(dirstate.copies().items()): | for f, s in sorted(dirstate.copies().items()): | ||||
| if f not in pctx and s not in pctx: | if f not in pctx and s not in pctx: | ||||
| dirstate.copy(None, f) | dirstate.copy(None, f) | ||||
| def _fileinfo(self, path): | def _fileinfo(self, path): | ||||
| # populate __dict__['_manifest'] as workingctx has no _manifestdelta | # populate __dict__['_manifest'] as workingctx has no _manifestdelta | ||||
| self._manifest | self._manifest | ||||
| return super(workingctx, self)._fileinfo(path) | return super(workingctx, self)._fileinfo(path) | ||||
| def _buildstatusmanifest(self, status): | def _buildstatusmanifest(self, status): | ||||
| """Builds a manifest that includes the given status results.""" | """Builds a manifest that includes the given status results.""" | ||||
| parents = self.parents() | parents = self.parents() | ||||
| man = parents[0].manifest().copy() | man = parents[0].manifest().copy() | ||||
| ff = self._flagfunc | ff = self._flagfunc | ||||
| for i, l in ( | for i, l in ( | ||||
| (addednodeid, status.added), | (self._repo.nodeconstants.addednodeid, status.added), | ||||
| (modifiednodeid, status.modified), | (self._repo.nodeconstants.modifiednodeid, status.modified), | ||||
| ): | ): | ||||
| for f in l: | for f in l: | ||||
| man[f] = i | man[f] = i | ||||
| try: | try: | ||||
| man.setflag(f, ff(f)) | man.setflag(f, ff(f)) | ||||
| except OSError: | except OSError: | ||||
| pass | pass | ||||
| def linkrev(self): | def linkrev(self): | ||||
| # linked to self._changectx no matter if file is modified or not | # linked to self._changectx no matter if file is modified or not | ||||
| return self.rev() | return self.rev() | ||||
| def renamed(self): | def renamed(self): | ||||
| path = self.copysource() | path = self.copysource() | ||||
| if not path: | if not path: | ||||
| return None | return None | ||||
| return path, self._changectx._parents[0]._manifest.get(path, nullid) | return ( | ||||
| path, | |||||
| self._changectx._parents[0]._manifest.get( | |||||
| path, self._repo.nodeconstants.nullid | |||||
| ), | |||||
| ) | |||||
| def parents(self): | def parents(self): | ||||
| '''return parent filectxs, following copies if necessary''' | '''return parent filectxs, following copies if necessary''' | ||||
| def filenode(ctx, path): | def filenode(ctx, path): | ||||
| return ctx._manifest.get(path, nullid) | return ctx._manifest.get(path, self._repo.nodeconstants.nullid) | ||||
| path = self._path | path = self._path | ||||
| fl = self._filelog | fl = self._filelog | ||||
| pcl = self._changectx._parents | pcl = self._changectx._parents | ||||
| renamed = self.renamed() | renamed = self.renamed() | ||||
| if renamed: | if renamed: | ||||
| pl = [renamed + (None,)] | pl = [renamed + (None,)] | ||||
| else: | else: | ||||
| pl = [(path, filenode(pcl[0], path), fl)] | pl = [(path, filenode(pcl[0], path), fl)] | ||||
| for pc in pcl[1:]: | for pc in pcl[1:]: | ||||
| pl.append((path, filenode(pc, path), fl)) | pl.append((path, filenode(pc, path), fl)) | ||||
| return [ | return [ | ||||
| self._parentfilectx(p, fileid=n, filelog=l) | self._parentfilectx(p, fileid=n, filelog=l) | ||||
| for p, n, l in pl | for p, n, l in pl | ||||
| if n != nullid | if n != self._repo.nodeconstants.nullid | ||||
| ] | ] | ||||
| def children(self): | def children(self): | ||||
| return [] | return [] | ||||
| class workingfilectx(committablefilectx): | class workingfilectx(committablefilectx): | ||||
| """A workingfilectx object makes access to data related to a particular | """A workingfilectx object makes access to data related to a particular | ||||
| def setbase(self, wrappedctx): | def setbase(self, wrappedctx): | ||||
| self._wrappedctx = wrappedctx | self._wrappedctx = wrappedctx | ||||
| self._parents = [wrappedctx] | self._parents = [wrappedctx] | ||||
| # Drop old manifest cache as it is now out of date. | # Drop old manifest cache as it is now out of date. | ||||
| # This is necessary when, e.g., rebasing several nodes with one | # This is necessary when, e.g., rebasing several nodes with one | ||||
| # ``overlayworkingctx`` (e.g. with --collapse). | # ``overlayworkingctx`` (e.g. with --collapse). | ||||
| util.clearcachedproperty(self, b'_manifest') | util.clearcachedproperty(self, b'_manifest') | ||||
| def setparents(self, p1node, p2node=nullid): | def setparents(self, p1node, p2node=None): | ||||
| if p2node is None: | |||||
| p2node = self._repo.nodeconstants.nullid | |||||
| assert p1node == self._wrappedctx.node() | assert p1node == self._wrappedctx.node() | ||||
| self._parents = [self._wrappedctx, self._repo.unfiltered()[p2node]] | self._parents = [self._wrappedctx, self._repo.unfiltered()[p2node]] | ||||
| def data(self, path): | def data(self, path): | ||||
| if self.isdirty(path): | if self.isdirty(path): | ||||
| if self._cache[path][b'exists']: | if self._cache[path][b'exists']: | ||||
| if self._cache[path][b'data'] is not None: | if self._cache[path][b'data'] is not None: | ||||
| return self._cache[path][b'data'] | return self._cache[path][b'data'] | ||||
| @propertycache | @propertycache | ||||
| def _manifest(self): | def _manifest(self): | ||||
| parents = self.parents() | parents = self.parents() | ||||
| man = parents[0].manifest().copy() | man = parents[0].manifest().copy() | ||||
| flag = self._flagfunc | flag = self._flagfunc | ||||
| for path in self.added(): | for path in self.added(): | ||||
| man[path] = addednodeid | man[path] = self._repo.nodeconstants.addednodeid | ||||
| man.setflag(path, flag(path)) | man.setflag(path, flag(path)) | ||||
| for path in self.modified(): | for path in self.modified(): | ||||
| man[path] = modifiednodeid | man[path] = self._repo.nodeconstants.modifiednodeid | ||||
| man.setflag(path, flag(path)) | man.setflag(path, flag(path)) | ||||
| for path in self.removed(): | for path in self.removed(): | ||||
| del man[path] | del man[path] | ||||
| return man | return man | ||||
| @propertycache | @propertycache | ||||
| def _flagfunc(self): | def _flagfunc(self): | ||||
| def f(path): | def f(path): | ||||
| branch=None, | branch=None, | ||||
| editor=None, | editor=None, | ||||
| ): | ): | ||||
| super(memctx, self).__init__( | super(memctx, self).__init__( | ||||
| repo, text, user, date, extra, branch=branch | repo, text, user, date, extra, branch=branch | ||||
| ) | ) | ||||
| self._rev = None | self._rev = None | ||||
| self._node = None | self._node = None | ||||
| parents = [(p or nullid) for p in parents] | parents = [(p or self._repo.nodeconstants.nullid) for p in parents] | ||||
| p1, p2 = parents | p1, p2 = parents | ||||
| self._parents = [self._repo[p] for p in (p1, p2)] | self._parents = [self._repo[p] for p in (p1, p2)] | ||||
| files = sorted(set(files)) | files = sorted(set(files)) | ||||
| self._files = files | self._files = files | ||||
| self.substate = {} | self.substate = {} | ||||
| if isinstance(filectxfn, patch.filestore): | if isinstance(filectxfn, patch.filestore): | ||||
| filectxfn = memfilefrompatch(filectxfn) | filectxfn = memfilefrompatch(filectxfn) | ||||
| def _manifest(self): | def _manifest(self): | ||||
| """generate a manifest based on the return values of filectxfn""" | """generate a manifest based on the return values of filectxfn""" | ||||
| # keep this simple for now; just worry about p1 | # keep this simple for now; just worry about p1 | ||||
| pctx = self._parents[0] | pctx = self._parents[0] | ||||
| man = pctx.manifest().copy() | man = pctx.manifest().copy() | ||||
| for f in self._status.modified: | for f in self._status.modified: | ||||
| man[f] = modifiednodeid | man[f] = self._repo.nodeconstants.modifiednodeid | ||||
| for f in self._status.added: | for f in self._status.added: | ||||
| man[f] = addednodeid | man[f] = self._repo.nodeconstants.addednodeid | ||||
| for f in self._status.removed: | for f in self._status.removed: | ||||
| if f in man: | if f in man: | ||||
| del man[f] | del man[f] | ||||
| return man | return man | ||||
| @propertycache | @propertycache | ||||
| parents = parents[:] | parents = parents[:] | ||||
| while len(parents) < 2: | while len(parents) < 2: | ||||
| parents.append(repo[nullrev]) | parents.append(repo[nullrev]) | ||||
| p1, p2 = self._parents = parents | p1, p2 = self._parents = parents | ||||
| # sanity check to ensure that the reused manifest parents are | # sanity check to ensure that the reused manifest parents are | ||||
| # manifests of our commit parents | # manifests of our commit parents | ||||
| mp1, mp2 = self.manifestctx().parents | mp1, mp2 = self.manifestctx().parents | ||||
| if p1 != nullid and p1.manifestnode() != mp1: | if p1 != self._repo.nodeconstants.nullid and p1.manifestnode() != mp1: | ||||
| raise RuntimeError( | raise RuntimeError( | ||||
| r"can't reuse the manifest: its p1 " | r"can't reuse the manifest: its p1 " | ||||
| r"doesn't match the new ctx p1" | r"doesn't match the new ctx p1" | ||||
| ) | ) | ||||
| if p2 != nullid and p2.manifestnode() != mp2: | if p2 != self._repo.nodeconstants.nullid and p2.manifestnode() != mp2: | ||||
| raise RuntimeError( | raise RuntimeError( | ||||
| r"can't reuse the manifest: " | r"can't reuse the manifest: " | ||||
| r"its p2 doesn't match the new ctx p2" | r"its p2 doesn't match the new ctx p2" | ||||
| ) | ) | ||||
| self._files = originalctx.files() | self._files = originalctx.files() | ||||
| self.substate = {} | self.substate = {} | ||||
| # coding: utf8 | # coding: utf8 | ||||
| # copies.py - copy detection for Mercurial | # copies.py - copy detection for Mercurial | ||||
| # | # | ||||
| # Copyright 2008 Olivia Mackall <olivia@selenic.com> | # Copyright 2008 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import os | import os | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import nullrev | ||||
| nullid, | |||||
| nullrev, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| match as matchmod, | match as matchmod, | ||||
| pathutil, | pathutil, | ||||
| policy, | policy, | ||||
| pycompat, | pycompat, | ||||
| util, | util, | ||||
| ) | ) | ||||
| def ismerged(path): | def ismerged(path): | ||||
| if path not in ctx.files(): | if path not in ctx.files(): | ||||
| return False | return False | ||||
| fctx = ctx[path] | fctx = ctx[path] | ||||
| parents = fctx._filelog.parents(fctx._filenode) | parents = fctx._filelog.parents(fctx._filenode) | ||||
| nb_parents = 0 | nb_parents = 0 | ||||
| for n in parents: | for n in parents: | ||||
| if n != nullid: | if n != repo.nullid: | ||||
| nb_parents += 1 | nb_parents += 1 | ||||
| return nb_parents >= 2 | return nb_parents >= 2 | ||||
| return ismerged | return ismerged | ||||
| def revinfo(rev): | def revinfo(rev): | ||||
| p1, p2 = parents(rev) | p1, p2 = parents(rev) | ||||
| ctx = repo[rev] | ctx = repo[rev] | ||||
| import subprocess | import subprocess | ||||
| import sys | import sys | ||||
| import time | import time | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from .pycompat import ( | from .pycompat import ( | ||||
| getattr, | getattr, | ||||
| open, | open, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| """dump an index DAG as a graphviz dot file""" | """dump an index DAG as a graphviz dot file""" | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| r = cmdutil.openstorage(repo, b'debugindexdot', file_, opts) | r = cmdutil.openstorage(repo, b'debugindexdot', file_, opts) | ||||
| ui.writenoi18n(b"digraph G {\n") | ui.writenoi18n(b"digraph G {\n") | ||||
| for i in r: | for i in r: | ||||
| node = r.node(i) | node = r.node(i) | ||||
| pp = r.parents(node) | pp = r.parents(node) | ||||
| ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i)) | ui.write(b"\t%d -> %d\n" % (r.rev(pp[0]), i)) | ||||
| if pp[1] != nullid: | if pp[1] != repo.nullid: | ||||
| ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i)) | ui.write(b"\t%d -> %d\n" % (r.rev(pp[1]), i)) | ||||
| ui.write(b"}\n") | ui.write(b"}\n") | ||||
| @command(b'debugindexstats', []) | @command(b'debugindexstats', []) | ||||
| def debugindexstats(ui, repo): | def debugindexstats(ui, repo): | ||||
| """show stats related to the changelog index""" | """show stats related to the changelog index""" | ||||
| repo.changelog.shortest(nullid, 1) | repo.changelog.shortest(repo.nullid, 1) | ||||
| index = repo.changelog.index | index = repo.changelog.index | ||||
| if not util.safehasattr(index, b'stats'): | if not util.safehasattr(index, b'stats'): | ||||
| raise error.Abort(_(b'debugindexstats only works with native code')) | raise error.Abort(_(b'debugindexstats only works with native code')) | ||||
| for k, v in sorted(index.stats().items()): | for k, v in sorted(index.stats().items()): | ||||
| ui.write(b'%s: %d\n' % (k, v)) | ui.write(b'%s: %d\n' % (k, v)) | ||||
| @command(b'debuginstall', [] + cmdutil.formatteropts, b'', norepo=True) | @command(b'debuginstall', [] + cmdutil.formatteropts, b'', norepo=True) | ||||
| opts = pycompat.byteskwargs(opts) | opts = pycompat.byteskwargs(opts) | ||||
| def parsenodeid(s): | def parsenodeid(s): | ||||
| try: | try: | ||||
| # We do not use revsingle/revrange functions here to accept | # We do not use revsingle/revrange functions here to accept | ||||
| # arbitrary node identifiers, possibly not present in the | # arbitrary node identifiers, possibly not present in the | ||||
| # local repository. | # local repository. | ||||
| n = bin(s) | n = bin(s) | ||||
| if len(n) != len(nullid): | if len(n) != repo.nodeconstants.nodelen: | ||||
| raise TypeError() | raise TypeError() | ||||
| return n | return n | ||||
| except TypeError: | except TypeError: | ||||
| raise error.InputError( | raise error.InputError( | ||||
| b'changeset references must be full hexadecimal ' | b'changeset references must be full hexadecimal ' | ||||
| b'node identifiers' | b'node identifiers' | ||||
| ) | ) | ||||
| ) | ) | ||||
| for i in r: | for i in r: | ||||
| node = r.node(i) | node = r.node(i) | ||||
| if format == 0: | if format == 0: | ||||
| try: | try: | ||||
| pp = r.parents(node) | pp = r.parents(node) | ||||
| except Exception: | except Exception: | ||||
| pp = [nullid, nullid] | pp = [repo.nullid, repo.nullid] | ||||
| if ui.verbose: | if ui.verbose: | ||||
| ui.write( | ui.write( | ||||
| b"% 6d % 9d % 7d % 7d %s %s %s\n" | b"% 6d % 9d % 7d % 7d %s %s %s\n" | ||||
| % ( | % ( | ||||
| i, | i, | ||||
| r.start(i), | r.start(i), | ||||
| r.length(i), | r.length(i), | ||||
| r.linkrev(i), | r.linkrev(i), | ||||
| def display(other, chlist, displayer): | def display(other, chlist, displayer): | ||||
| if opts.get(b"newest_first"): | if opts.get(b"newest_first"): | ||||
| chlist.reverse() | chlist.reverse() | ||||
| count = 0 | count = 0 | ||||
| for n in chlist: | for n in chlist: | ||||
| if limit is not None and count >= limit: | if limit is not None and count >= limit: | ||||
| break | break | ||||
| parents = [True for p in other.changelog.parents(n) if p != nullid] | parents = [ | ||||
| True for p in other.changelog.parents(n) if p != repo.nullid | |||||
| ] | |||||
| if opts.get(b"no_merges") and len(parents) == 2: | if opts.get(b"no_merges") and len(parents) == 2: | ||||
| continue | continue | ||||
| count += 1 | count += 1 | ||||
| displayer.show(other[n]) | displayer.show(other[n]) | ||||
| recovernode = opts.get(b"recover") | recovernode = opts.get(b"recover") | ||||
| if recovernode: | if recovernode: | ||||
| if scmutil.isrevsymbol(repo, recovernode): | if scmutil.isrevsymbol(repo, recovernode): | ||||
| # dirstate.py - working directory tracking for mercurial | # dirstate.py - working directory tracking for mercurial | ||||
| # | # | ||||
| # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import contextlib | import contextlib | ||||
| import errno | import errno | ||||
| import os | import os | ||||
| import stat | import stat | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import nullid | |||||
| from .pycompat import delattr | from .pycompat import delattr | ||||
| from hgdemandimport import tracing | from hgdemandimport import tracing | ||||
| from . import ( | from . import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| match as matchmod, | match as matchmod, | ||||
| return self._validate(self._pl[0]) | return self._validate(self._pl[0]) | ||||
| def p2(self): | def p2(self): | ||||
| return self._validate(self._pl[1]) | return self._validate(self._pl[1]) | ||||
| def branch(self): | def branch(self): | ||||
| return encoding.tolocal(self._branch) | return encoding.tolocal(self._branch) | ||||
| def setparents(self, p1, p2=nullid): | def setparents(self, p1, p2=None): | ||||
| """Set dirstate parents to p1 and p2. | """Set dirstate parents to p1 and p2. | ||||
| When moving from two parents to one, 'm' merged entries a | When moving from two parents to one, 'm' merged entries a | ||||
| adjusted to normal and previous copy records discarded and | adjusted to normal and previous copy records discarded and | ||||
| returned by the call. | returned by the call. | ||||
| See localrepo.setparents() | See localrepo.setparents() | ||||
| """ | """ | ||||
| if p2 is None: | |||||
| p2 = self._nodeconstants.nullid | |||||
| if self._parentwriters == 0: | if self._parentwriters == 0: | ||||
| raise ValueError( | raise ValueError( | ||||
| b"cannot set dirstate parent outside of " | b"cannot set dirstate parent outside of " | ||||
| b"dirstate.parentchange context manager" | b"dirstate.parentchange context manager" | ||||
| ) | ) | ||||
| self._dirty = True | self._dirty = True | ||||
| oldp2 = self._pl[1] | oldp2 = self._pl[1] | ||||
| if self._origpl is None: | if self._origpl is None: | ||||
| self._origpl = self._pl | self._origpl = self._pl | ||||
| self._map.setparents(p1, p2) | self._map.setparents(p1, p2) | ||||
| copies = {} | copies = {} | ||||
| if oldp2 != nullid and p2 == nullid: | if ( | ||||
| oldp2 != self._nodeconstants.nullid | |||||
| and p2 == self._nodeconstants.nullid | |||||
| ): | |||||
| candidatefiles = self._map.nonnormalset.union( | candidatefiles = self._map.nonnormalset.union( | ||||
| self._map.otherparentset | self._map.otherparentset | ||||
| ) | ) | ||||
| for f in candidatefiles: | for f in candidatefiles: | ||||
| s = self._map.get(f) | s = self._map.get(f) | ||||
| if s is None: | if s is None: | ||||
| continue | continue | ||||
| if mtime > self._lastnormaltime: | if mtime > self._lastnormaltime: | ||||
| # Remember the most recent modification timeslot for status(), | # Remember the most recent modification timeslot for status(), | ||||
| # to make sure we won't miss future size-preserving file content | # to make sure we won't miss future size-preserving file content | ||||
| # modifications that happen within the same timeslot. | # modifications that happen within the same timeslot. | ||||
| self._lastnormaltime = mtime | self._lastnormaltime = mtime | ||||
| def normallookup(self, f): | def normallookup(self, f): | ||||
| '''Mark a file normal, but possibly dirty.''' | '''Mark a file normal, but possibly dirty.''' | ||||
| if self._pl[1] != nullid: | if self._pl[1] != self._nodeconstants.nullid: | ||||
| # if there is a merge going on and the file was either | # if there is a merge going on and the file was either | ||||
| # in state 'm' (-1) or coming from other parent (-2) before | # in state 'm' (-1) or coming from other parent (-2) before | ||||
| # being removed, restore that state. | # being removed, restore that state. | ||||
| entry = self._map.get(f) | entry = self._map.get(f) | ||||
| if entry is not None: | if entry is not None: | ||||
| if entry[0] == b'r' and entry[2] in (-1, -2): | if entry[0] == b'r' and entry[2] in (-1, -2): | ||||
| source = self._map.copymap.get(f) | source = self._map.copymap.get(f) | ||||
| if entry[2] == -1: | if entry[2] == -1: | ||||
| self.merge(f) | self.merge(f) | ||||
| elif entry[2] == -2: | elif entry[2] == -2: | ||||
| self.otherparent(f) | self.otherparent(f) | ||||
| if source: | if source: | ||||
| self.copy(source, f) | self.copy(source, f) | ||||
| return | return | ||||
| if entry[0] == b'm' or entry[0] == b'n' and entry[2] == -2: | if entry[0] == b'm' or entry[0] == b'n' and entry[2] == -2: | ||||
| return | return | ||||
| self._addpath(f, b'n', 0, -1, -1) | self._addpath(f, b'n', 0, -1, -1) | ||||
| self._map.copymap.pop(f, None) | self._map.copymap.pop(f, None) | ||||
| def otherparent(self, f): | def otherparent(self, f): | ||||
| '''Mark as coming from the other parent, always dirty.''' | '''Mark as coming from the other parent, always dirty.''' | ||||
| if self._pl[1] == nullid: | if self._pl[1] == self._nodeconstants.nullid: | ||||
| raise error.Abort( | raise error.Abort( | ||||
| _(b"setting %r to other parent only allowed in merges") % f | _(b"setting %r to other parent only allowed in merges") % f | ||||
| ) | ) | ||||
| if f in self and self[f] == b'n': | if f in self and self[f] == b'n': | ||||
| # merge-like | # merge-like | ||||
| self._addpath(f, b'm', 0, -2, -1) | self._addpath(f, b'm', 0, -2, -1) | ||||
| else: | else: | ||||
| # add-like | # add-like | ||||
| self._addpath(f, b'n', 0, -2, -1) | self._addpath(f, b'n', 0, -2, -1) | ||||
| self._map.copymap.pop(f, None) | self._map.copymap.pop(f, None) | ||||
| def add(self, f): | def add(self, f): | ||||
| '''Mark a file added.''' | '''Mark a file added.''' | ||||
| self._addpath(f, b'a', 0, -1, -1) | self._addpath(f, b'a', 0, -1, -1) | ||||
| self._map.copymap.pop(f, None) | self._map.copymap.pop(f, None) | ||||
| def remove(self, f): | def remove(self, f): | ||||
| '''Mark a file removed.''' | '''Mark a file removed.''' | ||||
| self._dirty = True | self._dirty = True | ||||
| oldstate = self[f] | oldstate = self[f] | ||||
| size = 0 | size = 0 | ||||
| if self._pl[1] != nullid: | if self._pl[1] != self._nodeconstants.nullid: | ||||
| entry = self._map.get(f) | entry = self._map.get(f) | ||||
| if entry is not None: | if entry is not None: | ||||
| # backup the previous state | # backup the previous state | ||||
| if entry[0] == b'm': # merge | if entry[0] == b'm': # merge | ||||
| size = -1 | size = -1 | ||||
| elif entry[0] == b'n' and entry[2] == -2: # other parent | elif entry[0] == b'n' and entry[2] == -2: # other parent | ||||
| size = -2 | size = -2 | ||||
| self._map.otherparentset.add(f) | self._map.otherparentset.add(f) | ||||
| self._updatedfiles.add(f) | self._updatedfiles.add(f) | ||||
| self._map.removefile(f, oldstate, size) | self._map.removefile(f, oldstate, size) | ||||
| if size == 0: | if size == 0: | ||||
| self._map.copymap.pop(f, None) | self._map.copymap.pop(f, None) | ||||
| def merge(self, f): | def merge(self, f): | ||||
| '''Mark a file merged.''' | '''Mark a file merged.''' | ||||
| if self._pl[1] == nullid: | if self._pl[1] == self._nodeconstants.nullid: | ||||
| return self.normallookup(f) | return self.normallookup(f) | ||||
| return self.otherparent(f) | return self.otherparent(f) | ||||
| def drop(self, f): | def drop(self, f): | ||||
| '''Drop a file from the dirstate''' | '''Drop a file from the dirstate''' | ||||
| oldstate = self[f] | oldstate = self[f] | ||||
| if self._map.dropfile(f, oldstate): | if self._map.dropfile(f, oldstate): | ||||
| self._dirty = True | self._dirty = True | ||||
| to_drop.append(f) | to_drop.append(f) | ||||
| else: | else: | ||||
| changedfilesset = set(changedfiles) | changedfilesset = set(changedfiles) | ||||
| to_lookup = changedfilesset & set(allfiles) | to_lookup = changedfilesset & set(allfiles) | ||||
| to_drop = changedfilesset - to_lookup | to_drop = changedfilesset - to_lookup | ||||
| if self._origpl is None: | if self._origpl is None: | ||||
| self._origpl = self._pl | self._origpl = self._pl | ||||
| self._map.setparents(parent, nullid) | self._map.setparents(parent, self._nodeconstants.nullid) | ||||
| for f in to_lookup: | for f in to_lookup: | ||||
| self.normallookup(f) | self.normallookup(f) | ||||
| for f in to_drop: | for f in to_drop: | ||||
| self.drop(f) | self.drop(f) | ||||
| self._dirty = True | self._dirty = True | ||||
| def copymap(self): | def copymap(self): | ||||
| self.copymap = {} | self.copymap = {} | ||||
| self._map | self._map | ||||
| return self.copymap | return self.copymap | ||||
| def clear(self): | def clear(self): | ||||
| self._map.clear() | self._map.clear() | ||||
| self.copymap.clear() | self.copymap.clear() | ||||
| self.setparents(nullid, nullid) | self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid) | ||||
| util.clearcachedproperty(self, b"_dirs") | util.clearcachedproperty(self, b"_dirs") | ||||
| util.clearcachedproperty(self, b"_alldirs") | util.clearcachedproperty(self, b"_alldirs") | ||||
| util.clearcachedproperty(self, b"filefoldmap") | util.clearcachedproperty(self, b"filefoldmap") | ||||
| util.clearcachedproperty(self, b"dirfoldmap") | util.clearcachedproperty(self, b"dirfoldmap") | ||||
| util.clearcachedproperty(self, b"nonnormalset") | util.clearcachedproperty(self, b"nonnormalset") | ||||
| util.clearcachedproperty(self, b"otherparentset") | util.clearcachedproperty(self, b"otherparentset") | ||||
| def items(self): | def items(self): | ||||
| l = len(st) | l = len(st) | ||||
| if l == self._nodelen * 2: | if l == self._nodelen * 2: | ||||
| self._parents = ( | self._parents = ( | ||||
| st[: self._nodelen], | st[: self._nodelen], | ||||
| st[self._nodelen : 2 * self._nodelen], | st[self._nodelen : 2 * self._nodelen], | ||||
| ) | ) | ||||
| elif l == 0: | elif l == 0: | ||||
| self._parents = (nullid, nullid) | self._parents = ( | ||||
| self._nodeconstants.nullid, | |||||
| self._nodeconstants.nullid, | |||||
| ) | |||||
| else: | else: | ||||
| raise error.Abort( | raise error.Abort( | ||||
| _(b'working directory state appears damaged!') | _(b'working directory state appears damaged!') | ||||
| ) | ) | ||||
| return self._parents | return self._parents | ||||
| def setparents(self, p1, p2): | def setparents(self, p1, p2): | ||||
| return self._rustmap.copymap() | return self._rustmap.copymap() | ||||
| def preload(self): | def preload(self): | ||||
| self._rustmap | self._rustmap | ||||
| def clear(self): | def clear(self): | ||||
| self._rustmap.clear() | self._rustmap.clear() | ||||
| self._inner_rustmap.clear() | self._inner_rustmap.clear() | ||||
| self.setparents(nullid, nullid) | self.setparents( | ||||
| self._nodeconstants.nullid, self._nodeconstants.nullid | |||||
| ) | |||||
| util.clearcachedproperty(self, b"_dirs") | util.clearcachedproperty(self, b"_dirs") | ||||
| util.clearcachedproperty(self, b"_alldirs") | util.clearcachedproperty(self, b"_alldirs") | ||||
| util.clearcachedproperty(self, b"dirfoldmap") | util.clearcachedproperty(self, b"dirfoldmap") | ||||
| def items(self): | def items(self): | ||||
| return self._rustmap.items() | return self._rustmap.items() | ||||
| def keys(self): | def keys(self): | ||||
| # discovery.py - protocol changeset discovery functions | # discovery.py - protocol changeset discovery functions | ||||
| # | # | ||||
| # Copyright 2010 Olivia Mackall <olivia@selenic.com> | # Copyright 2010 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import functools | import functools | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| short, | short, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| bookmarks, | bookmarks, | ||||
| branchmap, | branchmap, | ||||
| error, | error, | ||||
| phases, | phases, | ||||
| # at least one of them must not be set | # at least one of them must not be set | ||||
| assert None in (commonheads, missingroots) | assert None in (commonheads, missingroots) | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| if ancestorsof is None: | if ancestorsof is None: | ||||
| ancestorsof = cl.heads() | ancestorsof = cl.heads() | ||||
| if missingroots: | if missingroots: | ||||
| discbases = [] | discbases = [] | ||||
| for n in missingroots: | for n in missingroots: | ||||
| discbases.extend([p for p in cl.parents(n) if p != nullid]) | discbases.extend([p for p in cl.parents(n) if p != repo.nullid]) | ||||
| # TODO remove call to nodesbetween. | # TODO remove call to nodesbetween. | ||||
| # TODO populate attributes on outgoing instance instead of setting | # TODO populate attributes on outgoing instance instead of setting | ||||
| # discbases. | # discbases. | ||||
| csets, roots, heads = cl.nodesbetween(missingroots, ancestorsof) | csets, roots, heads = cl.nodesbetween(missingroots, ancestorsof) | ||||
| included = set(csets) | included = set(csets) | ||||
| ancestorsof = heads | ancestorsof = heads | ||||
| commonheads = [n for n in discbases if n not in included] | commonheads = [n for n in discbases if n not in included] | ||||
| elif not commonheads: | elif not commonheads: | ||||
| commonheads = [nullid] | commonheads = [repo.nullid] | ||||
| self.commonheads = commonheads | self.commonheads = commonheads | ||||
| self.ancestorsof = ancestorsof | self.ancestorsof = ancestorsof | ||||
| self._revlog = cl | self._revlog = cl | ||||
| self._common = None | self._common = None | ||||
| self._missing = None | self._missing = None | ||||
| self.excluded = [] | self.excluded = [] | ||||
| def _computecommonmissing(self): | def _computecommonmissing(self): | ||||
| inc = bool(pushop.incoming) | inc = bool(pushop.incoming) | ||||
| # Check for each named branch if we're creating new remote heads. | # Check for each named branch if we're creating new remote heads. | ||||
| # To be a remote head after push, node must be either: | # To be a remote head after push, node must be either: | ||||
| # - unknown locally | # - unknown locally | ||||
| # - a local outgoing head descended from update | # - a local outgoing head descended from update | ||||
| # - a remote head that's known locally and not | # - a remote head that's known locally and not | ||||
| # ancestral to an outgoing head | # ancestral to an outgoing head | ||||
| if remoteheads == [nullid]: | if remoteheads == [repo.nullid]: | ||||
| # remote is empty, nothing to check. | # remote is empty, nothing to check. | ||||
| return | return | ||||
| if remote.capable(b'branchmap'): | if remote.capable(b'branchmap'): | ||||
| headssum = _headssummary(pushop) | headssum = _headssummary(pushop) | ||||
| else: | else: | ||||
| headssum = _oldheadssummary(repo, remoteheads, outgoing, inc) | headssum = _oldheadssummary(repo, remoteheads, outgoing, inc) | ||||
| pushop.pushbranchmap = headssum | pushop.pushbranchmap = headssum | ||||
| # exchange.py - utility to exchange data between repos. | # exchange.py - utility to exchange data between repos. | ||||
| # | # | ||||
| # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import weakref | import weakref | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| bookmarks as bookmod, | bookmarks as bookmod, | ||||
| bundle2, | bundle2, | ||||
| bundlecaches, | bundlecaches, | ||||
| changegroup, | changegroup, | ||||
| discovery, | discovery, | ||||
| Returns a discovery.outgoing object. | Returns a discovery.outgoing object. | ||||
| """ | """ | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| if common: | if common: | ||||
| hasnode = cl.hasnode | hasnode = cl.hasnode | ||||
| common = [n for n in common if hasnode(n)] | common = [n for n in common if hasnode(n)] | ||||
| else: | else: | ||||
| common = [nullid] | common = [repo.nullid] | ||||
| if not heads: | if not heads: | ||||
| heads = cl.heads() | heads = cl.heads() | ||||
| return discovery.outgoing(repo, common, heads) | return discovery.outgoing(repo, common, heads) | ||||
| def _checkpublish(pushop): | def _checkpublish(pushop): | ||||
| repo = pushop.repo | repo = pushop.repo | ||||
| ui = repo.ui | ui = repo.ui | ||||
| # If this is a full pull / clone and the server supports the clone bundles | # If this is a full pull / clone and the server supports the clone bundles | ||||
| # feature, tell the server whether we attempted a clone bundle. The | # feature, tell the server whether we attempted a clone bundle. The | ||||
| # presence of this flag indicates the client supports clone bundles. This | # presence of this flag indicates the client supports clone bundles. This | ||||
| # will enable the server to treat clients that support clone bundles | # will enable the server to treat clients that support clone bundles | ||||
| # differently from those that don't. | # differently from those that don't. | ||||
| if ( | if ( | ||||
| pullop.remote.capable(b'clonebundles') | pullop.remote.capable(b'clonebundles') | ||||
| and pullop.heads is None | and pullop.heads is None | ||||
| and list(pullop.common) == [nullid] | and list(pullop.common) == [pullop.repo.nullid] | ||||
| ): | ): | ||||
| kwargs[b'cbattempted'] = pullop.clonebundleattempted | kwargs[b'cbattempted'] = pullop.clonebundleattempted | ||||
| if streaming: | if streaming: | ||||
| pullop.repo.ui.status(_(b'streaming all changes\n')) | pullop.repo.ui.status(_(b'streaming all changes\n')) | ||||
| elif not pullop.fetch: | elif not pullop.fetch: | ||||
| pullop.repo.ui.status(_(b"no changes found\n")) | pullop.repo.ui.status(_(b"no changes found\n")) | ||||
| pullop.cgresult = 0 | pullop.cgresult = 0 | ||||
| else: | else: | ||||
| if pullop.heads is None and list(pullop.common) == [nullid]: | if pullop.heads is None and list(pullop.common) == [pullop.repo.nullid]: | ||||
| pullop.repo.ui.status(_(b"requesting all changes\n")) | pullop.repo.ui.status(_(b"requesting all changes\n")) | ||||
| if obsolete.isenabled(pullop.repo, obsolete.exchangeopt): | if obsolete.isenabled(pullop.repo, obsolete.exchangeopt): | ||||
| remoteversions = bundle2.obsmarkersversion(pullop.remotebundle2caps) | remoteversions = bundle2.obsmarkersversion(pullop.remotebundle2caps) | ||||
| if obsolete.commonversion(remoteversions) is not None: | if obsolete.commonversion(remoteversions) is not None: | ||||
| kwargs[b'obsmarkers'] = True | kwargs[b'obsmarkers'] = True | ||||
| pullop.stepsdone.add(b'obsmarkers') | pullop.stepsdone.add(b'obsmarkers') | ||||
| _pullbundle2extraprepare(pullop, kwargs) | _pullbundle2extraprepare(pullop, kwargs) | ||||
| if b'changegroup' in pullop.stepsdone: | if b'changegroup' in pullop.stepsdone: | ||||
| return | return | ||||
| pullop.stepsdone.add(b'changegroup') | pullop.stepsdone.add(b'changegroup') | ||||
| if not pullop.fetch: | if not pullop.fetch: | ||||
| pullop.repo.ui.status(_(b"no changes found\n")) | pullop.repo.ui.status(_(b"no changes found\n")) | ||||
| pullop.cgresult = 0 | pullop.cgresult = 0 | ||||
| return | return | ||||
| tr = pullop.gettransaction() | tr = pullop.gettransaction() | ||||
| if pullop.heads is None and list(pullop.common) == [nullid]: | if pullop.heads is None and list(pullop.common) == [pullop.repo.nullid]: | ||||
| pullop.repo.ui.status(_(b"requesting all changes\n")) | pullop.repo.ui.status(_(b"requesting all changes\n")) | ||||
| elif pullop.heads is None and pullop.remote.capable(b'changegroupsubset'): | elif pullop.heads is None and pullop.remote.capable(b'changegroupsubset'): | ||||
| # issue1320, avoid a race if remote changed after discovery | # issue1320, avoid a race if remote changed after discovery | ||||
| pullop.heads = pullop.rheads | pullop.heads = pullop.rheads | ||||
| if pullop.remote.capable(b'getbundle'): | if pullop.remote.capable(b'getbundle'): | ||||
| # TODO: get bundlecaps from remote | # TODO: get bundlecaps from remote | ||||
| cg = pullop.remote.getbundle( | cg = pullop.remote.getbundle( | ||||
| # exchangev2.py - repository exchange for wire protocol version 2 | # exchangev2.py - repository exchange for wire protocol version 2 | ||||
| # | # | ||||
| # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> | # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import weakref | import weakref | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import short | ||||
| nullid, | |||||
| short, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| bookmarks, | bookmarks, | ||||
| error, | error, | ||||
| mdiff, | mdiff, | ||||
| narrowspec, | narrowspec, | ||||
| phases, | phases, | ||||
| pycompat, | pycompat, | ||||
| requirements as requirementsmod, | requirements as requirementsmod, | ||||
| if fetch and remoteheads: | if fetch and remoteheads: | ||||
| has_node = repo.unfiltered().changelog.index.has_node | has_node = repo.unfiltered().changelog.index.has_node | ||||
| common |= {head for head in remoteheads if has_node(head)} | common |= {head for head in remoteheads if has_node(head)} | ||||
| if set(remoteheads).issubset(common): | if set(remoteheads).issubset(common): | ||||
| fetch = [] | fetch = [] | ||||
| common.discard(nullid) | common.discard(repo.nullid) | ||||
| return common, fetch, remoteheads | return common, fetch, remoteheads | ||||
| def _fetchchangesets(repo, tr, remote, common, fetch, remoteheads): | def _fetchchangesets(repo, tr, remote, common, fetch, remoteheads): | ||||
| # TODO consider adding a step here where we obtain the DAG shape first | # TODO consider adding a step here where we obtain the DAG shape first | ||||
| # (or ask the server to slice changesets into chunks for us) so that | # (or ask the server to slice changesets into chunks for us) so that | ||||
| # we can perform multiple fetches in batches. This will facilitate | # we can perform multiple fetches in batches. This will facilitate | ||||
| yield ( | yield ( | ||||
| node, | node, | ||||
| cset[b'parents'][0], | cset[b'parents'][0], | ||||
| cset[b'parents'][1], | cset[b'parents'][1], | ||||
| # Linknode is always itself for changesets. | # Linknode is always itself for changesets. | ||||
| cset[b'node'], | cset[b'node'], | ||||
| # We always send full revisions. So delta base is not set. | # We always send full revisions. So delta base is not set. | ||||
| nullid, | repo.nullid, | ||||
| mdiff.trivialdiffheader(len(data)) + data, | mdiff.trivialdiffheader(len(data)) + data, | ||||
| # Flags not yet supported. | # Flags not yet supported. | ||||
| 0, | 0, | ||||
| # Sidedata not yet supported | # Sidedata not yet supported | ||||
| {}, | {}, | ||||
| ) | ) | ||||
| cl.addgroup( | cl.addgroup( | ||||
| for field, size in manifest.get(b'fieldsfollowing', []): | for field, size in manifest.get(b'fieldsfollowing', []): | ||||
| extrafields[field] = next(objs) | extrafields[field] = next(objs) | ||||
| if b'delta' in extrafields: | if b'delta' in extrafields: | ||||
| basenode = manifest[b'deltabasenode'] | basenode = manifest[b'deltabasenode'] | ||||
| delta = extrafields[b'delta'] | delta = extrafields[b'delta'] | ||||
| elif b'revision' in extrafields: | elif b'revision' in extrafields: | ||||
| basenode = nullid | basenode = repo.nullid | ||||
| revision = extrafields[b'revision'] | revision = extrafields[b'revision'] | ||||
| delta = mdiff.trivialdiffheader(len(revision)) + revision | delta = mdiff.trivialdiffheader(len(revision)) + revision | ||||
| else: | else: | ||||
| continue | continue | ||||
| yield ( | yield ( | ||||
| node, | node, | ||||
| manifest[b'parents'][0], | manifest[b'parents'][0], | ||||
| for field, size in filerevision.get(b'fieldsfollowing', []): | for field, size in filerevision.get(b'fieldsfollowing', []): | ||||
| extrafields[field] = next(objs) | extrafields[field] = next(objs) | ||||
| if b'delta' in extrafields: | if b'delta' in extrafields: | ||||
| basenode = filerevision[b'deltabasenode'] | basenode = filerevision[b'deltabasenode'] | ||||
| delta = extrafields[b'delta'] | delta = extrafields[b'delta'] | ||||
| elif b'revision' in extrafields: | elif b'revision' in extrafields: | ||||
| basenode = nullid | basenode = repo.nullid | ||||
| revision = extrafields[b'revision'] | revision = extrafields[b'revision'] | ||||
| delta = mdiff.trivialdiffheader(len(revision)) + revision | delta = mdiff.trivialdiffheader(len(revision)) + revision | ||||
| else: | else: | ||||
| continue | continue | ||||
| yield ( | yield ( | ||||
| node, | node, | ||||
| filerevision[b'parents'][0], | filerevision[b'parents'][0], | ||||
| for field, size in filerevision.get(b'fieldsfollowing', []): | for field, size in filerevision.get(b'fieldsfollowing', []): | ||||
| extrafields[field] = next(objs) | extrafields[field] = next(objs) | ||||
| if b'delta' in extrafields: | if b'delta' in extrafields: | ||||
| basenode = filerevision[b'deltabasenode'] | basenode = filerevision[b'deltabasenode'] | ||||
| delta = extrafields[b'delta'] | delta = extrafields[b'delta'] | ||||
| elif b'revision' in extrafields: | elif b'revision' in extrafields: | ||||
| basenode = nullid | basenode = repo.nullid | ||||
| revision = extrafields[b'revision'] | revision = extrafields[b'revision'] | ||||
| delta = mdiff.trivialdiffheader(len(revision)) + revision | delta = mdiff.trivialdiffheader(len(revision)) + revision | ||||
| else: | else: | ||||
| continue | continue | ||||
| if b'linknode' in filerevision: | if b'linknode' in filerevision: | ||||
| linknode = filerevision[b'linknode'] | linknode = filerevision[b'linknode'] | ||||
| else: | else: | ||||
| # filelog.py - file history class for mercurial | # filelog.py - file history class for mercurial | ||||
| # | # | ||||
| # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import nullrev | ||||
| nullid, | |||||
| nullrev, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| error, | error, | ||||
| revlog, | revlog, | ||||
| ) | ) | ||||
| from .interfaces import ( | from .interfaces import ( | ||||
| repository, | repository, | ||||
| util as interfaceutil, | util as interfaceutil, | ||||
| ) | ) | ||||
| def __len__(self): | def __len__(self): | ||||
| return len(self._revlog) | return len(self._revlog) | ||||
| def __iter__(self): | def __iter__(self): | ||||
| return self._revlog.__iter__() | return self._revlog.__iter__() | ||||
| def hasnode(self, node): | def hasnode(self, node): | ||||
| if node in (nullid, nullrev): | if node in (self.nullid, nullrev): | ||||
| return False | return False | ||||
| try: | try: | ||||
| self._revlog.rev(node) | self._revlog.rev(node) | ||||
| return True | return True | ||||
| except (TypeError, ValueError, IndexError, error.LookupError): | except (TypeError, ValueError, IndexError, error.LookupError): | ||||
| return False | return False | ||||
| import contextlib | import contextlib | ||||
| import os | import os | ||||
| import re | import re | ||||
| import shutil | import shutil | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| short, | short, | ||||
| ) | ) | ||||
| from .pycompat import ( | from .pycompat import ( | ||||
| getattr, | getattr, | ||||
| open, | open, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| def size(self): | def size(self): | ||||
| return None | return None | ||||
| def data(self): | def data(self): | ||||
| return None | return None | ||||
| def filenode(self): | def filenode(self): | ||||
| return nullid | return self._ctx.repo().nullid | ||||
| _customcmp = True | _customcmp = True | ||||
| def cmp(self, fctx): | def cmp(self, fctx): | ||||
| """compare with other file context | """compare with other file context | ||||
| returns True if different from fctx. | returns True if different from fctx. | ||||
| """ | """ | ||||
| import errno | import errno | ||||
| import os | import os | ||||
| import shutil | import shutil | ||||
| import stat | import stat | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullhex, | sha1nodeconstants, | ||||
| nullid, | |||||
| short, | short, | ||||
| ) | ) | ||||
| from .pycompat import getattr | from .pycompat import getattr | ||||
| from . import ( | from . import ( | ||||
| bookmarks, | bookmarks, | ||||
| bundlerepo, | bundlerepo, | ||||
| cacheutil, | cacheutil, | ||||
| with srcpeer.commandexecutor() as e: | with srcpeer.commandexecutor() as e: | ||||
| rootnode = e.callcommand( | rootnode = e.callcommand( | ||||
| b'lookup', | b'lookup', | ||||
| { | { | ||||
| b'key': b'0', | b'key': b'0', | ||||
| }, | }, | ||||
| ).result() | ).result() | ||||
| if rootnode != nullid: | if rootnode != sha1nodeconstants.nullid: | ||||
| sharepath = os.path.join(sharepool, hex(rootnode)) | sharepath = os.path.join(sharepool, hex(rootnode)) | ||||
| else: | else: | ||||
| ui.status( | ui.status( | ||||
| _( | _( | ||||
| b'(not using pooled storage: ' | b'(not using pooled storage: ' | ||||
| b'remote appears to be empty)\n' | b'remote appears to be empty)\n' | ||||
| ) | ) | ||||
| ) | ) | ||||
| dstcachedir = os.path.join(destpath, b'cache') | dstcachedir = os.path.join(destpath, b'cache') | ||||
| for cache in cacheutil.cachetocopy(srcrepo): | for cache in cacheutil.cachetocopy(srcrepo): | ||||
| _copycache(srcrepo, dstcachedir, cache) | _copycache(srcrepo, dstcachedir, cache) | ||||
| # we need to re-init the repo after manually copying the data | # we need to re-init the repo after manually copying the data | ||||
| # into it | # into it | ||||
| destpeer = peer(srcrepo, peeropts, dest) | destpeer = peer(srcrepo, peeropts, dest) | ||||
| srcrepo.hook(b'outgoing', source=b'clone', node=nullhex) | srcrepo.hook( | ||||
| b'outgoing', source=b'clone', node=srcrepo.nodeconstants.nullhex | |||||
| ) | |||||
| else: | else: | ||||
| try: | try: | ||||
| # only pass ui when no srcrepo | # only pass ui when no srcrepo | ||||
| destpeer = peer( | destpeer = peer( | ||||
| srcrepo or ui, | srcrepo or ui, | ||||
| peeropts, | peeropts, | ||||
| dest, | dest, | ||||
| create=True, | create=True, | ||||
| def display(other, chlist, displayer): | def display(other, chlist, displayer): | ||||
| limit = logcmdutil.getlimit(opts) | limit = logcmdutil.getlimit(opts) | ||||
| if opts.get(b'newest_first'): | if opts.get(b'newest_first'): | ||||
| chlist.reverse() | chlist.reverse() | ||||
| count = 0 | count = 0 | ||||
| for n in chlist: | for n in chlist: | ||||
| if limit is not None and count >= limit: | if limit is not None and count >= limit: | ||||
| break | break | ||||
| parents = [p for p in other.changelog.parents(n) if p != nullid] | parents = [ | ||||
| p for p in other.changelog.parents(n) if p != repo.nullid | |||||
| ] | |||||
| if opts.get(b'no_merges') and len(parents) == 2: | if opts.get(b'no_merges') and len(parents) == 2: | ||||
| continue | continue | ||||
| count += 1 | count += 1 | ||||
| displayer.show(other[n]) | displayer.show(other[n]) | ||||
| return _incoming( | return _incoming( | ||||
| display, subreporecurse, ui, repo, source, opts, subpath=subpath | display, subreporecurse, ui, repo, source, opts, subpath=subpath | ||||
| ) | ) | ||||
| yield r | yield r | ||||
| return | return | ||||
| count = 0 | count = 0 | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| for n in revs: | for n in revs: | ||||
| if limit is not None and count >= limit: | if limit is not None and count >= limit: | ||||
| break | break | ||||
| parents = [p for p in cl.parents(n) if p != nullid] | parents = [p for p in cl.parents(n) if p != repo.nullid] | ||||
| if no_merges and len(parents) == 2: | if no_merges and len(parents) == 2: | ||||
| continue | continue | ||||
| count += 1 | count += 1 | ||||
| yield n | yield n | ||||
| def outgoing(ui, repo, dests, opts, subpath=None): | def outgoing(ui, repo, dests, opts, subpath=None): | ||||
| if opts.get(b'graph'): | if opts.get(b'graph'): | ||||
| # hgweb/webutil.py - utility library for the web interface. | # hgweb/webutil.py - utility library for the web interface. | ||||
| # | # | ||||
| # Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> | # Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> | ||||
| # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import copy | import copy | ||||
| import difflib | import difflib | ||||
| import os | import os | ||||
| import re | import re | ||||
| from ..i18n import _ | from ..i18n import _ | ||||
| from ..node import hex, nullid, short | from ..node import hex, short | ||||
| from ..pycompat import setattr | from ..pycompat import setattr | ||||
| from .common import ( | from .common import ( | ||||
| ErrorResponse, | ErrorResponse, | ||||
| HTTP_BAD_REQUEST, | HTTP_BAD_REQUEST, | ||||
| HTTP_NOT_FOUND, | HTTP_NOT_FOUND, | ||||
| paritygen, | paritygen, | ||||
| ) | ) | ||||
| if util.safehasattr(s, b'path'): | if util.safehasattr(s, b'path'): | ||||
| d[b'file'] = s.path() | d[b'file'] = s.path() | ||||
| yield d | yield d | ||||
| def _siblings(siblings=None, hiderev=None): | def _siblings(siblings=None, hiderev=None): | ||||
| if siblings is None: | if siblings is None: | ||||
| siblings = [] | siblings = [] | ||||
| siblings = [s for s in siblings if s.node() != nullid] | siblings = [s for s in siblings if s.node() != s.repo().nullid] | ||||
| if len(siblings) == 1 and siblings[0].rev() == hiderev: | if len(siblings) == 1 and siblings[0].rev() == hiderev: | ||||
| siblings = [] | siblings = [] | ||||
| return templateutil.mappinggenerator(_ctxsgen, args=(siblings,)) | return templateutil.mappinggenerator(_ctxsgen, args=(siblings,)) | ||||
| def difffeatureopts(req, ui, section): | def difffeatureopts(req, ui, section): | ||||
| diffopts = diffutil.difffeatureopts( | diffopts = diffutil.difffeatureopts( | ||||
| ui, untrusted=True, section=section, whitespace=True | ui, untrusted=True, section=section, whitespace=True | ||||
| return templateutil.hybridlist(branches, name=b'name') | return templateutil.hybridlist(branches, name=b'name') | ||||
| def _nodenamesgen(context, f, node, name): | def _nodenamesgen(context, f, node, name): | ||||
| for t in f(node): | for t in f(node): | ||||
| yield {name: t} | yield {name: t} | ||||
| def showtag(repo, t1, node=nullid): | def showtag(repo, t1, node=None): | ||||
| if node is None: | |||||
| node = repo.nullid | |||||
| args = (repo.nodetags, node, b'tag') | args = (repo.nodetags, node, b'tag') | ||||
| return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1) | return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1) | ||||
| def showbookmark(repo, t1, node=nullid): | def showbookmark(repo, t1, node=None): | ||||
| if node is None: | |||||
| node = repo.nullid | |||||
| args = (repo.nodebookmarks, node, b'bookmark') | args = (repo.nodebookmarks, node, b'bookmark') | ||||
| return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1) | return templateutil.mappinggenerator(_nodenamesgen, args=args, name=t1) | ||||
| def branchentries(repo, stripecount, limit=0): | def branchentries(repo, stripecount, limit=0): | ||||
| tips = [] | tips = [] | ||||
| heads = repo.heads() | heads = repo.heads() | ||||
| parity = paritygen(stripecount) | parity = paritygen(stripecount) | ||||
| from __future__ import absolute_import, print_function | from __future__ import absolute_import, print_function | ||||
| import contextlib | import contextlib | ||||
| from .. import node as nodemod | |||||
| from . import util as interfaceutil | from . import util as interfaceutil | ||||
| class idirstate(interfaceutil.Interface): | class idirstate(interfaceutil.Interface): | ||||
| def __init__(opener, ui, root, validate, sparsematchfn, nodeconstants): | def __init__(opener, ui, root, validate, sparsematchfn, nodeconstants): | ||||
| """Create a new dirstate object. | """Create a new dirstate object. | ||||
| opener is an open()-like callable that can be used to open the | opener is an open()-like callable that can be used to open the | ||||
| pass | pass | ||||
| def p2(): | def p2(): | ||||
| pass | pass | ||||
| def branch(): | def branch(): | ||||
| pass | pass | ||||
| def setparents(p1, p2=nodemod.nullid): | def setparents(p1, p2=None): | ||||
| """Set dirstate parents to p1 and p2. | """Set dirstate parents to p1 and p2. | ||||
| When moving from two parents to one, 'm' merged entries a | When moving from two parents to one, 'm' merged entries a | ||||
| adjusted to normal and previous copy records discarded and | adjusted to normal and previous copy records discarded and | ||||
| returned by the call. | returned by the call. | ||||
| See localrepo.setparents() | See localrepo.setparents() | ||||
| """ | """ | ||||
| import sys | import sys | ||||
| import time | import time | ||||
| import weakref | import weakref | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| sha1nodeconstants, | sha1nodeconstants, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from .pycompat import ( | from .pycompat import ( | ||||
| delattr, | delattr, | ||||
| getattr, | getattr, | ||||
| ) | ) | ||||
| return node | return node | ||||
| except error.LookupError: | except error.LookupError: | ||||
| if not self._dirstatevalidatewarned: | if not self._dirstatevalidatewarned: | ||||
| self._dirstatevalidatewarned = True | self._dirstatevalidatewarned = True | ||||
| self.ui.warn( | self.ui.warn( | ||||
| _(b"warning: ignoring unknown working parent %s!\n") | _(b"warning: ignoring unknown working parent %s!\n") | ||||
| % short(node) | % short(node) | ||||
| ) | ) | ||||
| return nullid | return self.nullid | ||||
| @storecache(narrowspec.FILENAME) | @storecache(narrowspec.FILENAME) | ||||
| def narrowpats(self): | def narrowpats(self): | ||||
| """matcher patterns for this repository's narrowspec | """matcher patterns for this repository's narrowspec | ||||
| A tuple of (includes, excludes). | A tuple of (includes, excludes). | ||||
| """ | """ | ||||
| return narrowspec.load(self) | return narrowspec.load(self) | ||||
| def setnarrowpats(self, newincludes, newexcludes): | def setnarrowpats(self, newincludes, newexcludes): | ||||
| narrowspec.save(self, newincludes, newexcludes) | narrowspec.save(self, newincludes, newexcludes) | ||||
| self.invalidate(clearfilecache=True) | self.invalidate(clearfilecache=True) | ||||
| @unfilteredpropertycache | @unfilteredpropertycache | ||||
| def _quick_access_changeid_null(self): | def _quick_access_changeid_null(self): | ||||
| return { | return { | ||||
| b'null': (nullrev, nullid), | b'null': (nullrev, self.nodeconstants.nullid), | ||||
| nullrev: (nullrev, nullid), | nullrev: (nullrev, self.nodeconstants.nullid), | ||||
| nullid: (nullrev, nullid), | self.nullid: (nullrev, self.nullid), | ||||
| } | } | ||||
| @unfilteredpropertycache | @unfilteredpropertycache | ||||
| def _quick_access_changeid_wc(self): | def _quick_access_changeid_wc(self): | ||||
| # also fast path access to the working copy parents | # also fast path access to the working copy parents | ||||
| # however, only do it for filter that ensure wc is visible. | # however, only do it for filter that ensure wc is visible. | ||||
| quick = self._quick_access_changeid_null.copy() | quick = self._quick_access_changeid_null.copy() | ||||
| cl = self.unfiltered().changelog | cl = self.unfiltered().changelog | ||||
| for node in self.dirstate.parents(): | for node in self.dirstate.parents(): | ||||
| if node == nullid: | if node == self.nullid: | ||||
| continue | continue | ||||
| rev = cl.index.get_rev(node) | rev = cl.index.get_rev(node) | ||||
| if rev is None: | if rev is None: | ||||
| # unknown working copy parent case: | # unknown working copy parent case: | ||||
| # | # | ||||
| # skip the fast path and let higher code deal with it | # skip the fast path and let higher code deal with it | ||||
| continue | continue | ||||
| pair = (rev, node) | pair = (rev, node) | ||||
| quick[rev] = pair | quick[rev] = pair | ||||
| quick[node] = pair | quick[node] = pair | ||||
| # also add the parents of the parents | # also add the parents of the parents | ||||
| for r in cl.parentrevs(rev): | for r in cl.parentrevs(rev): | ||||
| if r == nullrev: | if r == nullrev: | ||||
| continue | continue | ||||
| n = cl.node(r) | n = cl.node(r) | ||||
| pair = (r, n) | pair = (r, n) | ||||
| quick[r] = pair | quick[r] = pair | ||||
| quick[n] = pair | quick[n] = pair | ||||
| p1node = self.dirstate.p1() | p1node = self.dirstate.p1() | ||||
| if p1node != nullid: | if p1node != self.nullid: | ||||
| quick[b'.'] = quick[p1node] | quick[b'.'] = quick[p1node] | ||||
| return quick | return quick | ||||
| @unfilteredmethod | @unfilteredmethod | ||||
| def _quick_access_changeid_invalidate(self): | def _quick_access_changeid_invalidate(self): | ||||
| if '_quick_access_changeid_wc' in vars(self): | if '_quick_access_changeid_wc' in vars(self): | ||||
| del self.__dict__['_quick_access_changeid_wc'] | del self.__dict__['_quick_access_changeid_wc'] | ||||
| tagsmod.readlocaltags(self.ui, self, alltags, tagtypes) | tagsmod.readlocaltags(self.ui, self, alltags, tagtypes) | ||||
| # Build the return dicts. Have to re-encode tag names because | # Build the return dicts. Have to re-encode tag names because | ||||
| # the tags module always uses UTF-8 (in order not to lose info | # the tags module always uses UTF-8 (in order not to lose info | ||||
| # writing to the cache), but the rest of Mercurial wants them in | # writing to the cache), but the rest of Mercurial wants them in | ||||
| # local encoding. | # local encoding. | ||||
| tags = {} | tags = {} | ||||
| for (name, (node, hist)) in pycompat.iteritems(alltags): | for (name, (node, hist)) in pycompat.iteritems(alltags): | ||||
| if node != nullid: | if node != self.nullid: | ||||
| tags[encoding.tolocal(name)] = node | tags[encoding.tolocal(name)] = node | ||||
| tags[b'tip'] = self.changelog.tip() | tags[b'tip'] = self.changelog.tip() | ||||
| tagtypes = { | tagtypes = { | ||||
| encoding.tolocal(name): value | encoding.tolocal(name): value | ||||
| for (name, value) in pycompat.iteritems(tagtypes) | for (name, value) in pycompat.iteritems(tagtypes) | ||||
| } | } | ||||
| return (tags, tagtypes) | return (tags, tagtypes) | ||||
| '''the type of shared repository (None if not shared)''' | '''the type of shared repository (None if not shared)''' | ||||
| if self.sharedpath != self.path: | if self.sharedpath != self.path: | ||||
| return b'store' | return b'store' | ||||
| return None | return None | ||||
| def wjoin(self, f, *insidef): | def wjoin(self, f, *insidef): | ||||
| return self.vfs.reljoin(self.root, f, *insidef) | return self.vfs.reljoin(self.root, f, *insidef) | ||||
| def setparents(self, p1, p2=nullid): | def setparents(self, p1, p2=None): | ||||
| if p2 is None: | |||||
| p2 = self.nullid | |||||
| self[None].setparents(p1, p2) | self[None].setparents(p1, p2) | ||||
| self._quick_access_changeid_invalidate() | self._quick_access_changeid_invalidate() | ||||
| def filectx(self, path, changeid=None, fileid=None, changectx=None): | def filectx(self, path, changeid=None, fileid=None, changectx=None): | ||||
| """changeid must be a changeset revision, if specified. | """changeid must be a changeset revision, if specified. | ||||
| fileid can be a file revision or node.""" | fileid can be a file revision or node.""" | ||||
| return context.filectx( | return context.filectx( | ||||
| self, path, changeid, fileid, changectx=changectx | self, path, changeid, fileid, changectx=changectx | ||||
| _(b'committing subrepository %s\n') | _(b'committing subrepository %s\n') | ||||
| % uipathfn(subrepoutil.subrelpath(sub)) | % uipathfn(subrepoutil.subrelpath(sub)) | ||||
| ) | ) | ||||
| sr = sub.commit(cctx._text, user, date) | sr = sub.commit(cctx._text, user, date) | ||||
| newstate[s] = (newstate[s][0], sr) | newstate[s] = (newstate[s][0], sr) | ||||
| subrepoutil.writestate(self, newstate) | subrepoutil.writestate(self, newstate) | ||||
| p1, p2 = self.dirstate.parents() | p1, p2 = self.dirstate.parents() | ||||
| hookp1, hookp2 = hex(p1), (p2 != nullid and hex(p2) or b'') | hookp1, hookp2 = hex(p1), (p2 != self.nullid and hex(p2) or b'') | ||||
| try: | try: | ||||
| self.hook( | self.hook( | ||||
| b"precommit", throw=True, parent1=hookp1, parent2=hookp2 | b"precommit", throw=True, parent1=hookp1, parent2=hookp2 | ||||
| ) | ) | ||||
| with self.transaction(b'commit'): | with self.transaction(b'commit'): | ||||
| ret = self.commitctx(cctx, True) | ret = self.commitctx(cctx, True) | ||||
| # update bookmarks, dirstate and mergestate | # update bookmarks, dirstate and mergestate | ||||
| bookmarks.update(self, [p1, p2], ret) | bookmarks.update(self, [p1, p2], ret) | ||||
| def branches(self, nodes): | def branches(self, nodes): | ||||
| if not nodes: | if not nodes: | ||||
| nodes = [self.changelog.tip()] | nodes = [self.changelog.tip()] | ||||
| b = [] | b = [] | ||||
| for n in nodes: | for n in nodes: | ||||
| t = n | t = n | ||||
| while True: | while True: | ||||
| p = self.changelog.parents(n) | p = self.changelog.parents(n) | ||||
| if p[1] != nullid or p[0] == nullid: | if p[1] != self.nullid or p[0] == self.nullid: | ||||
| b.append((t, n, p[0], p[1])) | b.append((t, n, p[0], p[1])) | ||||
| break | break | ||||
| n = p[0] | n = p[0] | ||||
| return b | return b | ||||
| def between(self, pairs): | def between(self, pairs): | ||||
| r = [] | r = [] | ||||
| for top, bottom in pairs: | for top, bottom in pairs: | ||||
| n, l, i = top, [], 0 | n, l, i = top, [], 0 | ||||
| f = 1 | f = 1 | ||||
| while n != bottom and n != nullid: | while n != bottom and n != self.nullid: | ||||
| p = self.changelog.parents(n)[0] | p = self.changelog.parents(n)[0] | ||||
| if i == f: | if i == f: | ||||
| l.append(n) | l.append(n) | ||||
| f = f * 2 | f = f * 2 | ||||
| n = p | n = p | ||||
| i += 1 | i += 1 | ||||
| r.append(l) | r.append(l) | ||||
| # logcmdutil.py - utility for log-like commands | # logcmdutil.py - utility for log-like commands | ||||
| # | # | ||||
| # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import itertools | import itertools | ||||
| import os | import os | ||||
| import posixpath | import posixpath | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import nullrev, wdirrev | ||||
| nullid, | |||||
| nullrev, | |||||
| wdirid, | |||||
| wdirrev, | |||||
| ) | |||||
| from .thirdparty import attr | from .thirdparty import attr | ||||
| from . import ( | from . import ( | ||||
| dagop, | dagop, | ||||
| error, | error, | ||||
| formatter, | formatter, | ||||
| graphmod, | graphmod, | ||||
| label = b'log.parent changeset.%s' % pctx.phasestr() | label = b'log.parent changeset.%s' % pctx.phasestr() | ||||
| self.ui.write( | self.ui.write( | ||||
| columns[b'parent'] % scmutil.formatchangeid(pctx), label=label | columns[b'parent'] % scmutil.formatchangeid(pctx), label=label | ||||
| ) | ) | ||||
| if self.ui.debugflag: | if self.ui.debugflag: | ||||
| mnode = ctx.manifestnode() | mnode = ctx.manifestnode() | ||||
| if mnode is None: | if mnode is None: | ||||
| mnode = wdirid | mnode = self.repo.nodeconstants.wdirid | ||||
| mrev = wdirrev | mrev = wdirrev | ||||
| else: | else: | ||||
| mrev = self.repo.manifestlog.rev(mnode) | mrev = self.repo.manifestlog.rev(mnode) | ||||
| self.ui.write( | self.ui.write( | ||||
| columns[b'manifest'] | columns[b'manifest'] | ||||
| % scmutil.formatrevnode(self.ui, mrev, mnode), | % scmutil.formatrevnode(self.ui, mrev, mnode), | ||||
| label=b'ui.debug log.manifest', | label=b'ui.debug log.manifest', | ||||
| ) | ) | ||||
| bookmarks=fm.formatlist(ctx.bookmarks(), name=b'bookmark'), | bookmarks=fm.formatlist(ctx.bookmarks(), name=b'bookmark'), | ||||
| tags=fm.formatlist(ctx.tags(), name=b'tag'), | tags=fm.formatlist(ctx.tags(), name=b'tag'), | ||||
| parents=fm.formatlist( | parents=fm.formatlist( | ||||
| [fm.hexfunc(c.node()) for c in ctx.parents()], name=b'node' | [fm.hexfunc(c.node()) for c in ctx.parents()], name=b'node' | ||||
| ), | ), | ||||
| ) | ) | ||||
| if self.ui.debugflag or b'manifest' in datahint: | if self.ui.debugflag or b'manifest' in datahint: | ||||
| fm.data(manifest=fm.hexfunc(ctx.manifestnode() or wdirid)) | fm.data( | ||||
| manifest=fm.hexfunc( | |||||
| ctx.manifestnode() or self.repo.nodeconstants.wdirid | |||||
| ) | |||||
| ) | |||||
| if self.ui.debugflag or b'extra' in datahint: | if self.ui.debugflag or b'extra' in datahint: | ||||
| fm.data(extra=fm.formatdict(ctx.extra())) | fm.data(extra=fm.formatdict(ctx.extra())) | ||||
| if ( | if ( | ||||
| self.ui.debugflag | self.ui.debugflag | ||||
| or b'modified' in datahint | or b'modified' in datahint | ||||
| or b'added' in datahint | or b'added' in datahint | ||||
| or b'removed' in datahint | or b'removed' in datahint | ||||
| expr = None | expr = None | ||||
| return expr | return expr | ||||
| def _initialrevs(repo, wopts): | def _initialrevs(repo, wopts): | ||||
| """Return the initial set of revisions to be filtered or followed""" | """Return the initial set of revisions to be filtered or followed""" | ||||
| if wopts.revspec: | if wopts.revspec: | ||||
| revs = scmutil.revrange(repo, wopts.revspec) | revs = scmutil.revrange(repo, wopts.revspec) | ||||
| elif wopts.follow and repo.dirstate.p1() == nullid: | elif wopts.follow and repo.dirstate.p1() == repo.nullid: | ||||
| revs = smartset.baseset() | revs = smartset.baseset() | ||||
| elif wopts.follow: | elif wopts.follow: | ||||
| revs = repo.revs(b'.') | revs = repo.revs(b'.') | ||||
| else: | else: | ||||
| revs = smartset.spanset(repo) | revs = smartset.spanset(repo) | ||||
| revs.reverse() | revs.reverse() | ||||
| return revs | return revs | ||||
| import itertools | import itertools | ||||
| import struct | import struct | ||||
| import weakref | import weakref | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| ) | ) | ||||
| from .pycompat import getattr | from .pycompat import getattr | ||||
| from . import ( | from . import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| match as matchmod, | match as matchmod, | ||||
| mdiff, | mdiff, | ||||
| _noop = lambda s: None | _noop = lambda s: None | ||||
| @interfaceutil.implementer(repository.imanifestdict) | @interfaceutil.implementer(repository.imanifestdict) | ||||
| class treemanifest(object): | class treemanifest(object): | ||||
| def __init__(self, nodeconstants, dir=b'', text=b''): | def __init__(self, nodeconstants, dir=b'', text=b''): | ||||
| self._dir = dir | self._dir = dir | ||||
| self.nodeconstants = nodeconstants | self.nodeconstants = nodeconstants | ||||
| self._node = nullid | self._node = self.nodeconstants.nullid | ||||
| self._loadfunc = _noop | self._loadfunc = _noop | ||||
| self._copyfunc = _noop | self._copyfunc = _noop | ||||
| self._dirty = False | self._dirty = False | ||||
| self._dirs = {} | self._dirs = {} | ||||
| self._lazydirs = {} | self._lazydirs = {} | ||||
| # Using _lazymanifest here is a little slower than plain old dicts | # Using _lazymanifest here is a little slower than plain old dicts | ||||
| self._files = {} | self._files = {} | ||||
| self._flags = {} | self._flags = {} | ||||
| visit = self._loadchildrensetlazy(visit) | visit = self._loadchildrensetlazy(visit) | ||||
| if visit == b'this' or visit == b'all': | if visit == b'this' or visit == b'all': | ||||
| visit = None | visit = None | ||||
| for d, subm in pycompat.iteritems(self._dirs): | for d, subm in pycompat.iteritems(self._dirs): | ||||
| if visit and d[:-1] not in visit: | if visit and d[:-1] not in visit: | ||||
| continue | continue | ||||
| subp1 = getnode(m1, d) | subp1 = getnode(m1, d) | ||||
| subp2 = getnode(m2, d) | subp2 = getnode(m2, d) | ||||
| if subp1 == nullid: | if subp1 == self.nodeconstants.nullid: | ||||
| subp1, subp2 = subp2, subp1 | subp1, subp2 = subp2, subp1 | ||||
| writesubtree(subm, subp1, subp2, match) | writesubtree(subm, subp1, subp2, match) | ||||
| def walksubtrees(self, matcher=None): | def walksubtrees(self, matcher=None): | ||||
| """Returns an iterator of the subtrees of this manifest, including this | """Returns an iterator of the subtrees of this manifest, including this | ||||
| manifest itself. | manifest itself. | ||||
| If `matcher` is provided, it only returns subtrees that match. | If `matcher` is provided, it only returns subtrees that match. | ||||
| # Side-effect is LookupError is raised if node doesn't exist. | # Side-effect is LookupError is raised if node doesn't exist. | ||||
| self._rootstore.rev(node) | self._rootstore.rev(node) | ||||
| if self._treemanifests: | if self._treemanifests: | ||||
| m = treemanifestctx(self, b'', node) | m = treemanifestctx(self, b'', node) | ||||
| else: | else: | ||||
| m = manifestctx(self, node) | m = manifestctx(self, node) | ||||
| if node != nullid: | if node != self.nodeconstants.nullid: | ||||
| mancache = self._dirmancache.get(tree) | mancache = self._dirmancache.get(tree) | ||||
| if not mancache: | if not mancache: | ||||
| mancache = util.lrucachedict(self._cachesize) | mancache = util.lrucachedict(self._cachesize) | ||||
| self._dirmancache[tree] = mancache | self._dirmancache[tree] = mancache | ||||
| mancache[node] = m | mancache[node] = m | ||||
| return m | return m | ||||
| def getstorage(self, tree): | def getstorage(self, tree): | ||||
| return memmf | return memmf | ||||
| @propertycache | @propertycache | ||||
| def parents(self): | def parents(self): | ||||
| return self._storage().parents(self._node) | return self._storage().parents(self._node) | ||||
| def read(self): | def read(self): | ||||
| if self._data is None: | if self._data is None: | ||||
| if self._node == nullid: | if self._node == self._manifestlog.nodeconstants.nullid: | ||||
| self._data = manifestdict() | self._data = manifestdict() | ||||
| else: | else: | ||||
| store = self._storage() | store = self._storage() | ||||
| if self._node in store.fulltextcache: | if self._node in store.fulltextcache: | ||||
| text = pycompat.bytestr(store.fulltextcache[self._node]) | text = pycompat.bytestr(store.fulltextcache[self._node]) | ||||
| else: | else: | ||||
| text = store.revision(self._node) | text = store.revision(self._node) | ||||
| arraytext = bytearray(text) | arraytext = bytearray(text) | ||||
| return excludedmanifestrevlog( | return excludedmanifestrevlog( | ||||
| self._manifestlog.nodeconstants, self._dir | self._manifestlog.nodeconstants, self._dir | ||||
| ) | ) | ||||
| return self._manifestlog.getstorage(self._dir) | return self._manifestlog.getstorage(self._dir) | ||||
| def read(self): | def read(self): | ||||
| if self._data is None: | if self._data is None: | ||||
| store = self._storage() | store = self._storage() | ||||
| if self._node == nullid: | if self._node == self._manifestlog.nodeconstants.nullid: | ||||
| self._data = treemanifest(self._manifestlog.nodeconstants) | self._data = treemanifest(self._manifestlog.nodeconstants) | ||||
| # TODO accessing non-public API | # TODO accessing non-public API | ||||
| elif store._treeondisk: | elif store._treeondisk: | ||||
| m = treemanifest(self._manifestlog.nodeconstants, dir=self._dir) | m = treemanifest(self._manifestlog.nodeconstants, dir=self._dir) | ||||
| def gettext(): | def gettext(): | ||||
| return store.revision(self._node) | return store.revision(self._node) | ||||
| # merge.py - directory-level update/merge handling for Mercurial | # merge.py - directory-level update/merge handling for Mercurial | ||||
| # | # | ||||
| # Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import errno | import errno | ||||
| import stat | import stat | ||||
| import struct | import struct | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import nullrev | ||||
| addednodeid, | |||||
| modifiednodeid, | |||||
| nullid, | |||||
| nullrev, | |||||
| ) | |||||
| from .thirdparty import attr | from .thirdparty import attr | ||||
| from .utils import stringutil | from .utils import stringutil | ||||
| from . import ( | from . import ( | ||||
| copies, | copies, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| filemerge, | filemerge, | ||||
| match as matchmod, | match as matchmod, | ||||
| copied2 = set(branch_copies2.copy.values()) | copied2 = set(branch_copies2.copy.values()) | ||||
| copied2.update(branch_copies2.movewithdir.values()) | copied2.update(branch_copies2.movewithdir.values()) | ||||
| if b'.hgsubstate' in m1 and wctx.rev() is None: | if b'.hgsubstate' in m1 and wctx.rev() is None: | ||||
| # Check whether sub state is modified, and overwrite the manifest | # Check whether sub state is modified, and overwrite the manifest | ||||
| # to flag the change. If wctx is a committed revision, we shouldn't | # to flag the change. If wctx is a committed revision, we shouldn't | ||||
| # care for the dirty state of the working directory. | # care for the dirty state of the working directory. | ||||
| if any(wctx.sub(s).dirty() for s in wctx.substate): | if any(wctx.sub(s).dirty() for s in wctx.substate): | ||||
| m1[b'.hgsubstate'] = modifiednodeid | m1[b'.hgsubstate'] = repo.nodeconstants.modifiednodeid | ||||
| # Don't use m2-vs-ma optimization if: | # Don't use m2-vs-ma optimization if: | ||||
| # - ma is the same as m1 or m2, which we're just going to diff again later | # - ma is the same as m1 or m2, which we're just going to diff again later | ||||
| # - The caller specifically asks for a full diff, which is useful during bid | # - The caller specifically asks for a full diff, which is useful during bid | ||||
| # merge. | # merge. | ||||
| # - we are tracking salvaged files specifically hence should process all | # - we are tracking salvaged files specifically hence should process all | ||||
| # files | # files | ||||
| if ( | if ( | ||||
| mergestatemod.ACTION_CHANGED_DELETED, | mergestatemod.ACTION_CHANGED_DELETED, | ||||
| (f, None, f, False, pa.node()), | (f, None, f, False, pa.node()), | ||||
| b'prompt changed/deleted', | b'prompt changed/deleted', | ||||
| ) | ) | ||||
| if branchmerge: | if branchmerge: | ||||
| mresult.addcommitinfo( | mresult.addcommitinfo( | ||||
| f, b'merge-removal-candidate', b'yes' | f, b'merge-removal-candidate', b'yes' | ||||
| ) | ) | ||||
| elif n1 == addednodeid: | elif n1 == repo.nodeconstants.addednodeid: | ||||
| # This file was locally added. We should forget it instead of | # This file was locally added. We should forget it instead of | ||||
| # deleting it. | # deleting it. | ||||
| mresult.addfile( | mresult.addfile( | ||||
| f, | f, | ||||
| mergestatemod.ACTION_FORGET, | mergestatemod.ACTION_FORGET, | ||||
| None, | None, | ||||
| b'remote deleted', | b'remote deleted', | ||||
| ) | ) | ||||
| # itself because a) fsmonitor may have already printed a warning | # itself because a) fsmonitor may have already printed a warning | ||||
| # b) we only care about the config state here. | # b) we only care about the config state here. | ||||
| except KeyError: | except KeyError: | ||||
| fsmonitorenabled = False | fsmonitorenabled = False | ||||
| if ( | if ( | ||||
| fsmonitorwarning | fsmonitorwarning | ||||
| and not fsmonitorenabled | and not fsmonitorenabled | ||||
| and p1node == nullid | and p1node == repo.nullid | ||||
| and num_gets >= fsmonitorthreshold | and num_gets >= fsmonitorthreshold | ||||
| and pycompat.sysplatform.startswith((b'linux', b'darwin')) | and pycompat.sysplatform.startswith((b'linux', b'darwin')) | ||||
| ): | ): | ||||
| repo.ui.warn( | repo.ui.warn( | ||||
| _( | _( | ||||
| b'(warning: large working directory being used without ' | b'(warning: large working directory being used without ' | ||||
| b'fsmonitor enabled; enable fsmonitor to improve performance; ' | b'fsmonitor enabled; enable fsmonitor to improve performance; ' | ||||
| b'see "hg help -e fsmonitor")\n' | b'see "hg help -e fsmonitor")\n' | ||||
| pl = wc.parents() | pl = wc.parents() | ||||
| p1 = pl[0] | p1 = pl[0] | ||||
| p2 = repo[node] | p2 = repo[node] | ||||
| if ancestor is not None: | if ancestor is not None: | ||||
| pas = [repo[ancestor]] | pas = [repo[ancestor]] | ||||
| else: | else: | ||||
| if repo.ui.configlist(b'merge', b'preferancestor') == [b'*']: | if repo.ui.configlist(b'merge', b'preferancestor') == [b'*']: | ||||
| cahs = repo.changelog.commonancestorsheads(p1.node(), p2.node()) | cahs = repo.changelog.commonancestorsheads(p1.node(), p2.node()) | ||||
| pas = [repo[anc] for anc in (sorted(cahs) or [nullid])] | pas = [repo[anc] for anc in (sorted(cahs) or [repo.nullid])] | ||||
| else: | else: | ||||
| pas = [p1.ancestor(p2, warn=branchmerge)] | pas = [p1.ancestor(p2, warn=branchmerge)] | ||||
| fp1, fp2, xp1, xp2 = p1.node(), p2.node(), bytes(p1), bytes(p2) | fp1, fp2, xp1, xp2 = p1.node(), p2.node(), bytes(p1), bytes(p2) | ||||
| overwrite = force and not branchmerge | overwrite = force and not branchmerge | ||||
| ### check phase | ### check phase | ||||
| if not overwrite: | if not overwrite: | ||||
| ) | ) | ||||
| % f | % f | ||||
| ) | ) | ||||
| for nf in sorted(fl): | for nf in sorted(fl): | ||||
| repo.ui.warn(b" %s\n" % nf) | repo.ui.warn(b" %s\n" % nf) | ||||
| ### apply phase | ### apply phase | ||||
| if not branchmerge: # just jump to the new rev | if not branchmerge: # just jump to the new rev | ||||
| fp1, fp2, xp1, xp2 = fp2, nullid, xp2, b'' | fp1, fp2, xp1, xp2 = fp2, repo.nullid, xp2, b'' | ||||
| # If we're doing a partial update, we need to skip updating | # If we're doing a partial update, we need to skip updating | ||||
| # the dirstate. | # the dirstate. | ||||
| always = matcher is None or matcher.always() | always = matcher is None or matcher.always() | ||||
| updatedirstate = updatedirstate and always and not wc.isinmemory() | updatedirstate = updatedirstate and always and not wc.isinmemory() | ||||
| if updatedirstate: | if updatedirstate: | ||||
| repo.hook(b'preupdate', throw=True, parent1=xp1, parent2=xp2) | repo.hook(b'preupdate', throw=True, parent1=xp1, parent2=xp2) | ||||
| # note that we're in the middle of an update | # note that we're in the middle of an update | ||||
| repo.vfs.write(b'updatestate', p2.hex()) | repo.vfs.write(b'updatestate', p2.hex()) | ||||
| mergeancestor=mergeancestor, | mergeancestor=mergeancestor, | ||||
| labels=labels, | labels=labels, | ||||
| wc=wctx, | wc=wctx, | ||||
| ) | ) | ||||
| if keepconflictparent and stats.unresolvedcount: | if keepconflictparent and stats.unresolvedcount: | ||||
| pother = ctx.node() | pother = ctx.node() | ||||
| else: | else: | ||||
| pother = nullid | pother = repo.nullid | ||||
| parents = ctx.parents() | parents = ctx.parents() | ||||
| if keepparent and len(parents) == 2 and base in parents: | if keepparent and len(parents) == 2 and base in parents: | ||||
| parents.remove(base) | parents.remove(base) | ||||
| pother = parents[0].node() | pother = parents[0].node() | ||||
| # Never set both parents equal to each other | # Never set both parents equal to each other | ||||
| if pother == pctx.node(): | if pother == pctx.node(): | ||||
| pother = nullid | pother = repo.nullid | ||||
| if wctx.isinmemory(): | if wctx.isinmemory(): | ||||
| wctx.setparents(pctx.node(), pother) | wctx.setparents(pctx.node(), pother) | ||||
| # fix up dirstate for copies and renames | # fix up dirstate for copies and renames | ||||
| copies.graftcopies(wctx, ctx, base) | copies.graftcopies(wctx, ctx, base) | ||||
| else: | else: | ||||
| with repo.dirstate.parentchange(): | with repo.dirstate.parentchange(): | ||||
| repo.setparents(pctx.node(), pother) | repo.setparents(pctx.node(), pother) | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import errno | import errno | ||||
| import shutil | import shutil | ||||
| import struct | import struct | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullhex, | |||||
| nullrev, | nullrev, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| error, | error, | ||||
| filemerge, | filemerge, | ||||
| pycompat, | pycompat, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from .utils import hashutil | from .utils import hashutil | ||||
| _pack = struct.pack | _pack = struct.pack | ||||
| _unpack = struct.unpack | _unpack = struct.unpack | ||||
| def _droponode(data): | def _droponode(data): | ||||
| # used for compatibility for v1 | # used for compatibility for v1 | ||||
| bits = data.split(b'\0') | bits = data.split(b'\0') | ||||
| bits = bits[:-2] + bits[-1:] | bits = bits[:-2] + bits[-1:] | ||||
| return b'\0'.join(bits) | return b'\0'.join(bits) | ||||
| def _filectxorabsent(hexnode, ctx, f): | def _filectxorabsent(hexnode, ctx, f): | ||||
| if hexnode == nullhex: | if hexnode == ctx.repo().nodeconstants.nullhex: | ||||
| return filemerge.absentfilectx(ctx, f) | return filemerge.absentfilectx(ctx, f) | ||||
| else: | else: | ||||
| return ctx[f] | return ctx[f] | ||||
| # Merge state record types. See ``mergestate`` docs for more. | # Merge state record types. See ``mergestate`` docs for more. | ||||
| #### | #### | ||||
| fcl: file context for local, | fcl: file context for local, | ||||
| fco: file context for remote, | fco: file context for remote, | ||||
| fca: file context for ancestors, | fca: file context for ancestors, | ||||
| fd: file path of the resulting merge. | fd: file path of the resulting merge. | ||||
| note: also write the local version to the `.hg/merge` directory. | note: also write the local version to the `.hg/merge` directory. | ||||
| """ | """ | ||||
| if fcl.isabsent(): | if fcl.isabsent(): | ||||
| localkey = nullhex | localkey = self._repo.nodeconstants.nullhex | ||||
| else: | else: | ||||
| localkey = mergestate.getlocalkey(fcl.path()) | localkey = mergestate.getlocalkey(fcl.path()) | ||||
| self._make_backup(fcl, localkey) | self._make_backup(fcl, localkey) | ||||
| self._state[fd] = [ | self._state[fd] = [ | ||||
| MERGE_RECORD_UNRESOLVED, | MERGE_RECORD_UNRESOLVED, | ||||
| localkey, | localkey, | ||||
| fcl.path(), | fcl.path(), | ||||
| fca.path(), | fca.path(), | ||||
| b'without common ancestor - keeping local flags\n' | b'without common ancestor - keeping local flags\n' | ||||
| ) | ) | ||||
| % afile | % afile | ||||
| ) | ) | ||||
| elif flags == fla: | elif flags == fla: | ||||
| flags = flo | flags = flo | ||||
| if preresolve: | if preresolve: | ||||
| # restore local | # restore local | ||||
| if localkey != nullhex: | if localkey != self._repo.nodeconstants.nullhex: | ||||
| self._restore_backup(wctx[dfile], localkey, flags) | self._restore_backup(wctx[dfile], localkey, flags) | ||||
| else: | else: | ||||
| wctx[dfile].remove(ignoremissing=True) | wctx[dfile].remove(ignoremissing=True) | ||||
| complete, merge_ret, deleted = filemerge.premerge( | complete, merge_ret, deleted = filemerge.premerge( | ||||
| self._repo, | self._repo, | ||||
| wctx, | wctx, | ||||
| self._local, | self._local, | ||||
| lfile, | lfile, | ||||
| MERGE_RECORD_UNRESOLVED_PATH, | MERGE_RECORD_UNRESOLVED_PATH, | ||||
| MERGE_RECORD_RESOLVED_PATH, | MERGE_RECORD_RESOLVED_PATH, | ||||
| ): | ): | ||||
| # Path conflicts. These are stored in 'P' records. The current | # Path conflicts. These are stored in 'P' records. The current | ||||
| # resolution state ('pu' or 'pr') is stored within the record. | # resolution state ('pu' or 'pr') is stored within the record. | ||||
| records.append( | records.append( | ||||
| (RECORD_PATH_CONFLICT, b'\0'.join([filename] + v)) | (RECORD_PATH_CONFLICT, b'\0'.join([filename] + v)) | ||||
| ) | ) | ||||
| elif v[1] == nullhex or v[6] == nullhex: | elif ( | ||||
| v[1] == self._repo.nodeconstants.nullhex | |||||
| or v[6] == self._repo.nodeconstants.nullhex | |||||
| ): | |||||
| # Change/Delete or Delete/Change conflicts. These are stored in | # Change/Delete or Delete/Change conflicts. These are stored in | ||||
| # 'C' records. v[1] is the local file, and is nullhex when the | # 'C' records. v[1] is the local file, and is nullhex when the | ||||
| # file is deleted locally ('dc'). v[6] is the remote file, and | # file is deleted locally ('dc'). v[6] is the remote file, and | ||||
| # is nullhex when the file is deleted remotely ('cd'). | # is nullhex when the file is deleted remotely ('cd'). | ||||
| records.append( | records.append( | ||||
| (RECORD_CHANGEDELETE_CONFLICT, b'\0'.join([filename] + v)) | (RECORD_CHANGEDELETE_CONFLICT, b'\0'.join([filename] + v)) | ||||
| ) | ) | ||||
| else: | else: | ||||
| # coding: utf-8 | # coding: utf-8 | ||||
| # metadata.py -- code related to various metadata computation and access. | # metadata.py -- code related to various metadata computation and access. | ||||
| # | # | ||||
| # Copyright 2019 Google, Inc <martinvonz@google.com> | # Copyright 2019 Google, Inc <martinvonz@google.com> | ||||
| # Copyright 2020 Pierre-Yves David <pierre-yves.david@octobus.net> | # Copyright 2020 Pierre-Yves David <pierre-yves.david@octobus.net> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import, print_function | from __future__ import absolute_import, print_function | ||||
| import multiprocessing | import multiprocessing | ||||
| import struct | import struct | ||||
| from .node import ( | from .node import nullrev | ||||
| nullid, | |||||
| nullrev, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| error, | error, | ||||
| pycompat, | pycompat, | ||||
| requirements as requirementsmod, | requirements as requirementsmod, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from .revlogutils import ( | from .revlogutils import ( | ||||
| """return the list of files merged in a changeset""" | """return the list of files merged in a changeset""" | ||||
| merged = [] | merged = [] | ||||
| if len(ctx.parents()) < 2: | if len(ctx.parents()) < 2: | ||||
| return merged | return merged | ||||
| for f in ctx.files(): | for f in ctx.files(): | ||||
| if f in ctx: | if f in ctx: | ||||
| fctx = ctx[f] | fctx = ctx[f] | ||||
| parents = fctx._filelog.parents(fctx._filenode) | parents = fctx._filelog.parents(fctx._filenode) | ||||
| if parents[1] != nullid: | if parents[1] != ctx.repo().nullid: | ||||
| merged.append(f) | merged.append(f) | ||||
| return merged | return merged | ||||
| def computechangesetcopies(ctx): | def computechangesetcopies(ctx): | ||||
| """return the copies data for a changeset | """return the copies data for a changeset | ||||
| The copies data are returned as a pair of dictionnary (p1copies, p2copies). | The copies data are returned as a pair of dictionnary (p1copies, p2copies). | ||||
| """ | """ | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import errno | import errno | ||||
| import struct | import struct | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | |||||
| bin, | |||||
| hex, | |||||
| ) | |||||
| from .pycompat import getattr | from .pycompat import getattr | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| obsutil, | obsutil, | ||||
| phases, | phases, | ||||
| policy, | policy, | ||||
| pycompat, | pycompat, | ||||
| def _addchildren(children, markers): | def _addchildren(children, markers): | ||||
| for mark in markers: | for mark in markers: | ||||
| parents = mark[5] | parents = mark[5] | ||||
| if parents is not None: | if parents is not None: | ||||
| for p in parents: | for p in parents: | ||||
| children.setdefault(p, set()).add(mark) | children.setdefault(p, set()).add(mark) | ||||
| def _checkinvalidmarkers(markers): | def _checkinvalidmarkers(repo, markers): | ||||
| """search for marker with invalid data and raise error if needed | """search for marker with invalid data and raise error if needed | ||||
| Exist as a separated function to allow the evolve extension for a more | Exist as a separated function to allow the evolve extension for a more | ||||
| subtle handling. | subtle handling. | ||||
| """ | """ | ||||
| for mark in markers: | for mark in markers: | ||||
| if nullid in mark[1]: | if repo.nullid in mark[1]: | ||||
| raise error.Abort( | raise error.Abort( | ||||
| _( | _( | ||||
| b'bad obsolescence marker detected: ' | b'bad obsolescence marker detected: ' | ||||
| b'invalid successors nullid' | b'invalid successors nullid' | ||||
| ) | ) | ||||
| ) | ) | ||||
| @propertycache | @propertycache | ||||
| def _all(self): | def _all(self): | ||||
| data = self._data | data = self._data | ||||
| if not data: | if not data: | ||||
| return [] | return [] | ||||
| self._version, markers = _readmarkers(data) | self._version, markers = _readmarkers(data) | ||||
| markers = list(markers) | markers = list(markers) | ||||
| _checkinvalidmarkers(markers) | _checkinvalidmarkers(self.repo, markers) | ||||
| return markers | return markers | ||||
| @propertycache | @propertycache | ||||
| def successors(self): | def successors(self): | ||||
| successors = {} | successors = {} | ||||
| _addsuccessors(successors, self._all) | _addsuccessors(successors, self._all) | ||||
| return successors | return successors | ||||
| self._data = self._data + rawdata | self._data = self._data + rawdata | ||||
| self._all.extend(markers) | self._all.extend(markers) | ||||
| if self._cached('successors'): | if self._cached('successors'): | ||||
| _addsuccessors(self.successors, markers) | _addsuccessors(self.successors, markers) | ||||
| if self._cached('predecessors'): | if self._cached('predecessors'): | ||||
| _addpredecessors(self.predecessors, markers) | _addpredecessors(self.predecessors, markers) | ||||
| if self._cached('children'): | if self._cached('children'): | ||||
| _addchildren(self.children, markers) | _addchildren(self.children, markers) | ||||
| _checkinvalidmarkers(markers) | _checkinvalidmarkers(self.repo, markers) | ||||
| def relevantmarkers(self, nodes): | def relevantmarkers(self, nodes): | ||||
| """return a set of all obsolescence markers relevant to a set of nodes. | """return a set of all obsolescence markers relevant to a set of nodes. | ||||
| "relevant" to a set of nodes mean: | "relevant" to a set of nodes mean: | ||||
| - marker that use this changeset as successor | - marker that use this changeset as successor | ||||
| - prune marker of direct children on this changeset | - prune marker of direct children on this changeset | ||||
| import os | import os | ||||
| import re | import re | ||||
| import shutil | import shutil | ||||
| import zlib | import zlib | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullhex, | sha1nodeconstants, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from .pycompat import open | from .pycompat import open | ||||
| from . import ( | from . import ( | ||||
| copies, | copies, | ||||
| diffhelper, | diffhelper, | ||||
| diffutil, | diffutil, | ||||
| encoding, | encoding, | ||||
| opts: user passed options | opts: user passed options | ||||
| It exists as a separate function so that extensions like extdiff can wrap | It exists as a separate function so that extensions like extdiff can wrap | ||||
| it and use the file content directly. | it and use the file content directly. | ||||
| """ | """ | ||||
| ctx1, fctx1, path1, flag1, content1, date1 = data1 | ctx1, fctx1, path1, flag1, content1, date1 = data1 | ||||
| ctx2, fctx2, path2, flag2, content2, date2 = data2 | ctx2, fctx2, path2, flag2, content2, date2 = data2 | ||||
| index1 = _gitindex(content1) if path1 in ctx1 else nullhex | index1 = _gitindex(content1) if path1 in ctx1 else sha1nodeconstants.nullhex | ||||
| index2 = _gitindex(content2) if path2 in ctx2 else nullhex | index2 = _gitindex(content2) if path2 in ctx2 else sha1nodeconstants.nullhex | ||||
| if binary and opts.git and not opts.nobinary: | if binary and opts.git and not opts.nobinary: | ||||
| text = mdiff.b85diff(content1, content2) | text = mdiff.b85diff(content1, content2) | ||||
| if text: | if text: | ||||
| header.append(b'index %s..%s' % (index1, index2)) | header.append(b'index %s..%s' % (index1, index2)) | ||||
| hunks = ((None, [text]),) | hunks = ((None, [text]),) | ||||
| else: | else: | ||||
| if opts.git and opts.index > 0: | if opts.git and opts.index > 0: | ||||
| flag = flag1 | flag = flag1 | ||||
| import errno | import errno | ||||
| import struct | import struct | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| wdirrev, | wdirrev, | ||||
| ) | ) | ||||
| from .pycompat import ( | from .pycompat import ( | ||||
| getattr, | getattr, | ||||
| setattr, | setattr, | ||||
| ) | ) | ||||
| draftroots = [] | draftroots = [] | ||||
| has_node = repo.changelog.index.has_node # to filter unknown nodes | has_node = repo.changelog.index.has_node # to filter unknown nodes | ||||
| for nhex, phase in pycompat.iteritems(roots): | for nhex, phase in pycompat.iteritems(roots): | ||||
| if nhex == b'publishing': # ignore data related to publish option | if nhex == b'publishing': # ignore data related to publish option | ||||
| continue | continue | ||||
| node = bin(nhex) | node = bin(nhex) | ||||
| phase = int(phase) | phase = int(phase) | ||||
| if phase == public: | if phase == public: | ||||
| if node != nullid: | if node != repo.nullid: | ||||
| repo.ui.warn( | repo.ui.warn( | ||||
| _( | _( | ||||
| b'ignoring inconsistent public root' | b'ignoring inconsistent public root' | ||||
| b' from remote: %s\n' | b' from remote: %s\n' | ||||
| ) | ) | ||||
| % nhex | % nhex | ||||
| ) | ) | ||||
| elif phase == draft: | elif phase == draft: | ||||
| # phases > dagop > patch > copies > scmutil > obsolete > obsutil > phases | # phases > dagop > patch > copies > scmutil > obsolete > obsutil > phases | ||||
| from . import dagop | from . import dagop | ||||
| repo = repo.unfiltered() | repo = repo.unfiltered() | ||||
| cl = repo.changelog | cl = repo.changelog | ||||
| rev = cl.index.get_rev | rev = cl.index.get_rev | ||||
| if not roots: | if not roots: | ||||
| return heads | return heads | ||||
| if not heads or heads == [nullid]: | if not heads or heads == [repo.nullid]: | ||||
| return [] | return [] | ||||
| # The logic operated on revisions, convert arguments early for convenience | # The logic operated on revisions, convert arguments early for convenience | ||||
| new_heads = {rev(n) for n in heads if n != nullid} | new_heads = {rev(n) for n in heads if n != repo.nullid} | ||||
| roots = [rev(n) for n in roots] | roots = [rev(n) for n in roots] | ||||
| # compute the area we need to remove | # compute the area we need to remove | ||||
| affected_zone = repo.revs(b"(%ld::%ld)", roots, new_heads) | affected_zone = repo.revs(b"(%ld::%ld)", roots, new_heads) | ||||
| # heads in the area are no longer heads | # heads in the area are no longer heads | ||||
| new_heads.difference_update(affected_zone) | new_heads.difference_update(affected_zone) | ||||
| # revisions in the area have children outside of it, | # revisions in the area have children outside of it, | ||||
| # They might be new heads | # They might be new heads | ||||
| candidates = repo.revs( | candidates = repo.revs( | ||||
| # parsers.py - Python implementation of parsers.c | # parsers.py - Python implementation of parsers.c | ||||
| # | # | ||||
| # Copyright 2009 Olivia Mackall <olivia@selenic.com> and others | # Copyright 2009 Olivia Mackall <olivia@selenic.com> and others | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import struct | import struct | ||||
| import zlib | import zlib | ||||
| from ..node import nullid, nullrev | from ..node import ( | ||||
| nullrev, | |||||
| sha1nodeconstants, | |||||
| ) | |||||
| from .. import ( | from .. import ( | ||||
| pycompat, | pycompat, | ||||
| util, | util, | ||||
| ) | ) | ||||
| from ..revlogutils import nodemap as nodemaputil | from ..revlogutils import nodemap as nodemaputil | ||||
| from ..revlogutils import constants as revlog_constants | from ..revlogutils import constants as revlog_constants | ||||
| class BaseIndexObject(object): | class BaseIndexObject(object): | ||||
| # Format of an index entry according to Python's `struct` language | # Format of an index entry according to Python's `struct` language | ||||
| index_format = revlog_constants.INDEX_ENTRY_V1 | index_format = revlog_constants.INDEX_ENTRY_V1 | ||||
| # Size of a C unsigned long long int, platform independent | # Size of a C unsigned long long int, platform independent | ||||
| big_int_size = struct.calcsize(b'>Q') | big_int_size = struct.calcsize(b'>Q') | ||||
| # Size of a C long int, platform independent | # Size of a C long int, platform independent | ||||
| int_size = struct.calcsize(b'>i') | int_size = struct.calcsize(b'>i') | ||||
| # An empty index entry, used as a default value to be overridden, or nullrev | # An empty index entry, used as a default value to be overridden, or nullrev | ||||
| null_item = (0, 0, 0, -1, -1, -1, -1, nullid) | null_item = (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid) | ||||
| @util.propertycache | @util.propertycache | ||||
| def entry_size(self): | def entry_size(self): | ||||
| return self.index_format.size | return self.index_format.size | ||||
| @property | @property | ||||
| def nodemap(self): | def nodemap(self): | ||||
| msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" | msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" | ||||
| util.nouideprecwarn(msg, b'5.3', stacklevel=2) | util.nouideprecwarn(msg, b'5.3', stacklevel=2) | ||||
| return self._nodemap | return self._nodemap | ||||
| @util.propertycache | @util.propertycache | ||||
| def _nodemap(self): | def _nodemap(self): | ||||
| nodemap = nodemaputil.NodeMap({nullid: nullrev}) | nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev}) | ||||
| for r in range(0, len(self)): | for r in range(0, len(self)): | ||||
| n = self[r][7] | n = self[r][7] | ||||
| nodemap[n] = r | nodemap[n] = r | ||||
| return nodemap | return nodemap | ||||
| def has_node(self, node): | def has_node(self, node): | ||||
| """return True if the node exist in the index""" | """return True if the node exist in the index""" | ||||
| return node in self._nodemap | return node in self._nodemap | ||||
| cls = IndexObject2 if revlogv2 else IndexObject | cls = IndexObject2 if revlogv2 else IndexObject | ||||
| return cls(data), None | return cls(data), None | ||||
| cls = InlinedIndexObject2 if revlogv2 else InlinedIndexObject | cls = InlinedIndexObject2 if revlogv2 else InlinedIndexObject | ||||
| return cls(data, inline), (0, data) | return cls(data, inline), (0, data) | ||||
| class Index2Mixin(object): | class Index2Mixin(object): | ||||
| index_format = revlog_constants.INDEX_ENTRY_V2 | index_format = revlog_constants.INDEX_ENTRY_V2 | ||||
| null_item = (0, 0, 0, -1, -1, -1, -1, nullid, 0, 0) | null_item = (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid, 0, 0) | ||||
| def replace_sidedata_info(self, i, sidedata_offset, sidedata_length): | def replace_sidedata_info(self, i, sidedata_offset, sidedata_length): | ||||
| """ | """ | ||||
| Replace an existing index entry's sidedata offset and length with new | Replace an existing index entry's sidedata offset and length with new | ||||
| ones. | ones. | ||||
| This cannot be used outside of the context of sidedata rewriting, | This cannot be used outside of the context of sidedata rewriting, | ||||
| inside the transaction that creates the revision `i`. | inside the transaction that creates the revision `i`. | ||||
| """ | """ | ||||
| import os | import os | ||||
| import struct | import struct | ||||
| import zlib | import zlib | ||||
| # import stuff from node for others to import from revlog | # import stuff from node for others to import from revlog | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullhex, | |||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| sha1nodeconstants, | sha1nodeconstants, | ||||
| short, | short, | ||||
| wdirfilenodeids, | |||||
| wdirhex, | |||||
| wdirid, | |||||
| wdirrev, | wdirrev, | ||||
| ) | ) | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .pycompat import getattr | from .pycompat import getattr | ||||
| from .revlogutils.constants import ( | from .revlogutils.constants import ( | ||||
| FLAG_GENERALDELTA, | FLAG_GENERALDELTA, | ||||
| FLAG_INLINE_DATA, | FLAG_INLINE_DATA, | ||||
| INDEX_ENTRY_V0, | INDEX_ENTRY_V0, | ||||
| @property | @property | ||||
| def nodemap(self): | def nodemap(self): | ||||
| msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" | msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" | ||||
| util.nouideprecwarn(msg, b'5.3', stacklevel=2) | util.nouideprecwarn(msg, b'5.3', stacklevel=2) | ||||
| return self._nodemap | return self._nodemap | ||||
| @util.propertycache | @util.propertycache | ||||
| def _nodemap(self): | def _nodemap(self): | ||||
| nodemap = nodemaputil.NodeMap({nullid: nullrev}) | nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev}) | ||||
| for r in range(0, len(self)): | for r in range(0, len(self)): | ||||
| n = self[r][7] | n = self[r][7] | ||||
| nodemap[n] = r | nodemap[n] = r | ||||
| return nodemap | return nodemap | ||||
| def has_node(self, node): | def has_node(self, node): | ||||
| """return True if the node exist in the index""" | """return True if the node exist in the index""" | ||||
| return node in self._nodemap | return node in self._nodemap | ||||
| del self._nodemap[self[r][7]] | del self._nodemap[self[r][7]] | ||||
| super(revlogoldindex, self).__delitem__(i) | super(revlogoldindex, self).__delitem__(i) | ||||
| def clearcaches(self): | def clearcaches(self): | ||||
| self.__dict__.pop('_nodemap', None) | self.__dict__.pop('_nodemap', None) | ||||
| def __getitem__(self, i): | def __getitem__(self, i): | ||||
| if i == -1: | if i == -1: | ||||
| return (0, 0, 0, -1, -1, -1, -1, nullid) | return (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid) | ||||
| return list.__getitem__(self, i) | return list.__getitem__(self, i) | ||||
| class revlogoldio(object): | class revlogoldio(object): | ||||
| def parseindex(self, data, inline): | def parseindex(self, data, inline): | ||||
| s = INDEX_ENTRY_V0.size | s = INDEX_ENTRY_V0.size | ||||
| index = [] | index = [] | ||||
| nodemap = nodemaputil.NodeMap({nullid: nullrev}) | nodemap = nodemaputil.NodeMap({sha1nodeconstants.nullid: nullrev}) | ||||
| n = off = 0 | n = off = 0 | ||||
| l = len(data) | l = len(data) | ||||
| while off + s <= l: | while off + s <= l: | ||||
| cur = data[off : off + s] | cur = data[off : off + s] | ||||
| off += s | off += s | ||||
| e = INDEX_ENTRY_V0.unpack(cur) | e = INDEX_ENTRY_V0.unpack(cur) | ||||
| # transform to revlogv1 format | # transform to revlogv1 format | ||||
| e2 = ( | e2 = ( | ||||
| def rev(self, node): | def rev(self, node): | ||||
| try: | try: | ||||
| return self.index.rev(node) | return self.index.rev(node) | ||||
| except TypeError: | except TypeError: | ||||
| raise | raise | ||||
| except error.RevlogError: | except error.RevlogError: | ||||
| # parsers.c radix tree lookup failed | # parsers.c radix tree lookup failed | ||||
| if node == wdirid or node in wdirfilenodeids: | if ( | ||||
| node == self.nodeconstants.wdirid | |||||
| or node in self.nodeconstants.wdirfilenodeids | |||||
| ): | |||||
| raise error.WdirUnsupported | raise error.WdirUnsupported | ||||
| raise error.LookupError(node, self.indexfile, _(b'no node')) | raise error.LookupError(node, self.indexfile, _(b'no node')) | ||||
| # Accessors for index entries. | # Accessors for index entries. | ||||
| # First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes | # First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes | ||||
| # are flags. | # are flags. | ||||
| def start(self, rev): | def start(self, rev): | ||||
| def end(self, rev): | def end(self, rev): | ||||
| return self.start(rev) + self.length(rev) | return self.start(rev) + self.length(rev) | ||||
| def parents(self, node): | def parents(self, node): | ||||
| i = self.index | i = self.index | ||||
| d = i[self.rev(node)] | d = i[self.rev(node)] | ||||
| # inline node() to avoid function call overhead | # inline node() to avoid function call overhead | ||||
| if d[5] == nullid: | if d[5] == self.nullid: | ||||
| return i[d[6]][7], i[d[5]][7] | return i[d[6]][7], i[d[5]][7] | ||||
| else: | else: | ||||
| return i[d[5]][7], i[d[6]][7] | return i[d[5]][7], i[d[6]][7] | ||||
| def chainlen(self, rev): | def chainlen(self, rev): | ||||
| return self._chaininfo(rev)[0] | return self._chaininfo(rev)[0] | ||||
| def _chaininfo(self, rev): | def _chaininfo(self, rev): | ||||
| The list is sorted by revision number, meaning it is | The list is sorted by revision number, meaning it is | ||||
| topologically sorted. | topologically sorted. | ||||
| 'heads' and 'common' are both lists of node IDs. If heads is | 'heads' and 'common' are both lists of node IDs. If heads is | ||||
| not supplied, uses all of the revlog's heads. If common is not | not supplied, uses all of the revlog's heads. If common is not | ||||
| supplied, uses nullid.""" | supplied, uses nullid.""" | ||||
| if common is None: | if common is None: | ||||
| common = [nullid] | common = [self.nullid] | ||||
| if heads is None: | if heads is None: | ||||
| heads = self.heads() | heads = self.heads() | ||||
| common = [self.rev(n) for n in common] | common = [self.rev(n) for n in common] | ||||
| heads = [self.rev(n) for n in heads] | heads = [self.rev(n) for n in heads] | ||||
| # we want the ancestors, but inclusive | # we want the ancestors, but inclusive | ||||
| class lazyset(object): | class lazyset(object): | ||||
| The list is sorted by revision number, meaning it is | The list is sorted by revision number, meaning it is | ||||
| topologically sorted. | topologically sorted. | ||||
| 'heads' and 'common' are both lists of node IDs. If heads is | 'heads' and 'common' are both lists of node IDs. If heads is | ||||
| not supplied, uses all of the revlog's heads. If common is not | not supplied, uses all of the revlog's heads. If common is not | ||||
| supplied, uses nullid.""" | supplied, uses nullid.""" | ||||
| if common is None: | if common is None: | ||||
| common = [nullid] | common = [self.nullid] | ||||
| if heads is None: | if heads is None: | ||||
| heads = self.heads() | heads = self.heads() | ||||
| common = [self.rev(n) for n in common] | common = [self.rev(n) for n in common] | ||||
| heads = [self.rev(n) for n in heads] | heads = [self.rev(n) for n in heads] | ||||
| inc = self.incrementalmissingrevs(common=common) | inc = self.incrementalmissingrevs(common=common) | ||||
| return [self.node(r) for r in inc.missingancestors(heads)] | return [self.node(r) for r in inc.missingancestors(heads)] | ||||
| unspecified, uses list of all of the revlog's heads.""" | unspecified, uses list of all of the revlog's heads.""" | ||||
| nonodes = ([], [], []) | nonodes = ([], [], []) | ||||
| if roots is not None: | if roots is not None: | ||||
| roots = list(roots) | roots = list(roots) | ||||
| if not roots: | if not roots: | ||||
| return nonodes | return nonodes | ||||
| lowestrev = min([self.rev(n) for n in roots]) | lowestrev = min([self.rev(n) for n in roots]) | ||||
| else: | else: | ||||
| roots = [nullid] # Everybody's a descendant of nullid | roots = [self.nullid] # Everybody's a descendant of nullid | ||||
| lowestrev = nullrev | lowestrev = nullrev | ||||
| if (lowestrev == nullrev) and (heads is None): | if (lowestrev == nullrev) and (heads is None): | ||||
| # We want _all_ the nodes! | # We want _all_ the nodes! | ||||
| return ([self.node(r) for r in self], [nullid], list(self.heads())) | return ( | ||||
| [self.node(r) for r in self], | |||||
| [self.nullid], | |||||
| list(self.heads()), | |||||
| ) | |||||
| if heads is None: | if heads is None: | ||||
| # All nodes are ancestors, so the latest ancestor is the last | # All nodes are ancestors, so the latest ancestor is the last | ||||
| # node. | # node. | ||||
| highestrev = len(self) - 1 | highestrev = len(self) - 1 | ||||
| # Set ancestors to None to signal that every node is an ancestor. | # Set ancestors to None to signal that every node is an ancestor. | ||||
| ancestors = None | ancestors = None | ||||
| # Set heads to an empty dictionary for later discovery of heads | # Set heads to an empty dictionary for later discovery of heads | ||||
| heads = {} | heads = {} | ||||
| # Start at the top and keep marking parents until we're done. | # Start at the top and keep marking parents until we're done. | ||||
| nodestotag = set(heads) | nodestotag = set(heads) | ||||
| # Remember where the top was so we can use it as a limit later. | # Remember where the top was so we can use it as a limit later. | ||||
| highestrev = max([self.rev(n) for n in nodestotag]) | highestrev = max([self.rev(n) for n in nodestotag]) | ||||
| while nodestotag: | while nodestotag: | ||||
| # grab a node to tag | # grab a node to tag | ||||
| n = nodestotag.pop() | n = nodestotag.pop() | ||||
| # Never tag nullid | # Never tag nullid | ||||
| if n == nullid: | if n == self.nullid: | ||||
| continue | continue | ||||
| # A node's revision number represents its place in a | # A node's revision number represents its place in a | ||||
| # topologically sorted list of nodes. | # topologically sorted list of nodes. | ||||
| r = self.rev(n) | r = self.rev(n) | ||||
| if r >= lowestrev: | if r >= lowestrev: | ||||
| if n not in ancestors: | if n not in ancestors: | ||||
| # If we are possibly a descendant of one of the roots | # If we are possibly a descendant of one of the roots | ||||
| # and we haven't already been marked as an ancestor | # and we haven't already been marked as an ancestor | ||||
| ancestors.add(n) # Mark as ancestor | ancestors.add(n) # Mark as ancestor | ||||
| # Add non-nullid parents to list of nodes to tag. | # Add non-nullid parents to list of nodes to tag. | ||||
| nodestotag.update( | nodestotag.update( | ||||
| [p for p in self.parents(n) if p != nullid] | [p for p in self.parents(n) if p != self.nullid] | ||||
| ) | ) | ||||
| elif n in heads: # We've seen it before, is it a fake head? | elif n in heads: # We've seen it before, is it a fake head? | ||||
| # So it is, real heads should not be the ancestors of | # So it is, real heads should not be the ancestors of | ||||
| # any other heads. | # any other heads. | ||||
| heads.pop(n) | heads.pop(n) | ||||
| if not ancestors: | if not ancestors: | ||||
| return nonodes | return nonodes | ||||
| # Now that we have our set of ancestors, we want to remove any | # Now that we have our set of ancestors, we want to remove any | ||||
| lowestrev = min([self.rev(root) for root in roots]) | lowestrev = min([self.rev(root) for root in roots]) | ||||
| else: | else: | ||||
| # No more roots? Return empty list | # No more roots? Return empty list | ||||
| return nonodes | return nonodes | ||||
| else: | else: | ||||
| # We are descending from nullid, and don't need to care about | # We are descending from nullid, and don't need to care about | ||||
| # any other roots. | # any other roots. | ||||
| lowestrev = nullrev | lowestrev = nullrev | ||||
| roots = [nullid] | roots = [self.nullid] | ||||
| # Transform our roots list into a set. | # Transform our roots list into a set. | ||||
| descendants = set(roots) | descendants = set(roots) | ||||
| # Also, keep the original roots so we can filter out roots that aren't | # Also, keep the original roots so we can filter out roots that aren't | ||||
| # 'real' roots (i.e. are descended from other roots). | # 'real' roots (i.e. are descended from other roots). | ||||
| roots = descendants.copy() | roots = descendants.copy() | ||||
| # Our topologically sorted list of output nodes. | # Our topologically sorted list of output nodes. | ||||
| orderedout = [] | orderedout = [] | ||||
| # Don't start at nullid since we don't want nullid in our output list, | # Don't start at nullid since we don't want nullid in our output list, | ||||
| if start is specified, only heads that are descendants of | if start is specified, only heads that are descendants of | ||||
| start will be returned | start will be returned | ||||
| if stop is specified, it will consider all the revs from stop | if stop is specified, it will consider all the revs from stop | ||||
| as if they had no children | as if they had no children | ||||
| """ | """ | ||||
| if start is None and stop is None: | if start is None and stop is None: | ||||
| if not len(self): | if not len(self): | ||||
| return [nullid] | return [self.nullid] | ||||
| return [self.node(r) for r in self.headrevs()] | return [self.node(r) for r in self.headrevs()] | ||||
| if start is None: | if start is None: | ||||
| start = nullrev | start = nullrev | ||||
| else: | else: | ||||
| start = self.rev(start) | start = self.rev(start) | ||||
| stoprevs = {self.rev(n) for n in stop or []} | stoprevs = {self.rev(n) for n in stop or []} | ||||
| a, b = self.rev(a), self.rev(b) | a, b = self.rev(a), self.rev(b) | ||||
| try: | try: | ||||
| ancs = self.index.ancestors(a, b) | ancs = self.index.ancestors(a, b) | ||||
| except (AttributeError, OverflowError): | except (AttributeError, OverflowError): | ||||
| ancs = ancestor.ancestors(self.parentrevs, a, b) | ancs = ancestor.ancestors(self.parentrevs, a, b) | ||||
| if ancs: | if ancs: | ||||
| # choose a consistent winner when there's a tie | # choose a consistent winner when there's a tie | ||||
| return min(map(self.node, ancs)) | return min(map(self.node, ancs)) | ||||
| return nullid | return self.nullid | ||||
| def _match(self, id): | def _match(self, id): | ||||
| if isinstance(id, int): | if isinstance(id, int): | ||||
| # rev | # rev | ||||
| return self.node(id) | return self.node(id) | ||||
| if len(id) == 20: | if len(id) == 20: | ||||
| # possibly a binary node | # possibly a binary node | ||||
| # odds of a binary node being all hex in ASCII are 1 in 10**25 | # odds of a binary node being all hex in ASCII are 1 in 10**25 | ||||
| node = bin(id) | node = bin(id) | ||||
| self.rev(node) | self.rev(node) | ||||
| return node | return node | ||||
| except (TypeError, error.LookupError): | except (TypeError, error.LookupError): | ||||
| pass | pass | ||||
| def _partialmatch(self, id): | def _partialmatch(self, id): | ||||
| # we don't care wdirfilenodeids as they should be always full hash | # we don't care wdirfilenodeids as they should be always full hash | ||||
| maybewdir = wdirhex.startswith(id) | maybewdir = self.nodeconstants.wdirhex.startswith(id) | ||||
| try: | try: | ||||
| partial = self.index.partialmatch(id) | partial = self.index.partialmatch(id) | ||||
| if partial and self.hasnode(partial): | if partial and self.hasnode(partial): | ||||
| if maybewdir: | if maybewdir: | ||||
| # single 'ff...' match in radix tree, ambiguous with wdir | # single 'ff...' match in radix tree, ambiguous with wdir | ||||
| raise error.RevlogError | raise error.RevlogError | ||||
| return partial | return partial | ||||
| if maybewdir: | if maybewdir: | ||||
| try: | try: | ||||
| # hex(node)[:...] | # hex(node)[:...] | ||||
| l = len(id) // 2 # grab an even number of digits | l = len(id) // 2 # grab an even number of digits | ||||
| prefix = bin(id[: l * 2]) | prefix = bin(id[: l * 2]) | ||||
| nl = [e[7] for e in self.index if e[7].startswith(prefix)] | nl = [e[7] for e in self.index if e[7].startswith(prefix)] | ||||
| nl = [ | nl = [ | ||||
| n for n in nl if hex(n).startswith(id) and self.hasnode(n) | n for n in nl if hex(n).startswith(id) and self.hasnode(n) | ||||
| ] | ] | ||||
| if nullhex.startswith(id): | if self.nodeconstants.nullhex.startswith(id): | ||||
| nl.append(nullid) | nl.append(self.nullid) | ||||
| if len(nl) > 0: | if len(nl) > 0: | ||||
| if len(nl) == 1 and not maybewdir: | if len(nl) == 1 and not maybewdir: | ||||
| self._pcache[id] = nl[0] | self._pcache[id] = nl[0] | ||||
| return nl[0] | return nl[0] | ||||
| raise error.AmbiguousPrefixLookupError( | raise error.AmbiguousPrefixLookupError( | ||||
| id, self.indexfile, _(b'ambiguous identifier') | id, self.indexfile, _(b'ambiguous identifier') | ||||
| ) | ) | ||||
| if maybewdir: | if maybewdir: | ||||
| if not maybewdir(prefix): | if not maybewdir(prefix): | ||||
| return prefix | return prefix | ||||
| if not getattr(self, 'filteredrevs', None): | if not getattr(self, 'filteredrevs', None): | ||||
| try: | try: | ||||
| length = max(self.index.shortest(node), minlength) | length = max(self.index.shortest(node), minlength) | ||||
| return disambiguate(hexnode, length) | return disambiguate(hexnode, length) | ||||
| except error.RevlogError: | except error.RevlogError: | ||||
| if node != wdirid: | if node != self.nodeconstants.wdirid: | ||||
| raise error.LookupError(node, self.indexfile, _(b'no node')) | raise error.LookupError(node, self.indexfile, _(b'no node')) | ||||
| except AttributeError: | except AttributeError: | ||||
| # Fall through to pure code | # Fall through to pure code | ||||
| pass | pass | ||||
| if node == wdirid: | if node == self.nodeconstants.wdirid: | ||||
| for length in range(minlength, len(hexnode) + 1): | for length in range(minlength, len(hexnode) + 1): | ||||
| prefix = hexnode[:length] | prefix = hexnode[:length] | ||||
| if isvalid(prefix): | if isvalid(prefix): | ||||
| return prefix | return prefix | ||||
| for length in range(minlength, len(hexnode) + 1): | for length in range(minlength, len(hexnode) + 1): | ||||
| prefix = hexnode[:length] | prefix = hexnode[:length] | ||||
| if isvalid(prefix): | if isvalid(prefix): | ||||
| if isinstance(nodeorrev, int): | if isinstance(nodeorrev, int): | ||||
| rev = nodeorrev | rev = nodeorrev | ||||
| node = self.node(rev) | node = self.node(rev) | ||||
| else: | else: | ||||
| node = nodeorrev | node = nodeorrev | ||||
| rev = None | rev = None | ||||
| # fast path the special `nullid` rev | # fast path the special `nullid` rev | ||||
| if node == nullid: | if node == self.nullid: | ||||
| return b"", {} | return b"", {} | ||||
| # ``rawtext`` is the text as stored inside the revlog. Might be the | # ``rawtext`` is the text as stored inside the revlog. Might be the | ||||
| # revision or might need to be processed to retrieve the revision. | # revision or might need to be processed to retrieve the revision. | ||||
| rev, rawtext, validated = self._rawtext(node, rev, _df=_df) | rev, rawtext, validated = self._rawtext(node, rev, _df=_df) | ||||
| if self.version & 0xFFFF == REVLOGV2: | if self.version & 0xFFFF == REVLOGV2: | ||||
| if rev is None: | if rev is None: | ||||
| if "deltacomputer" is not provided or None, a defaultdeltacomputer will | if "deltacomputer" is not provided or None, a defaultdeltacomputer will | ||||
| be used. | be used. | ||||
| invariants: | invariants: | ||||
| - rawtext is optional (can be None); if not set, cachedelta must be set. | - rawtext is optional (can be None); if not set, cachedelta must be set. | ||||
| if both are set, they must correspond to each other. | if both are set, they must correspond to each other. | ||||
| """ | """ | ||||
| if node == nullid: | if node == self.nullid: | ||||
| raise error.RevlogError( | raise error.RevlogError( | ||||
| _(b"%s: attempt to add null revision") % self.indexfile | _(b"%s: attempt to add null revision") % self.indexfile | ||||
| ) | ) | ||||
| if node == wdirid or node in wdirfilenodeids: | if ( | ||||
| node == self.nodeconstants.wdirid | |||||
| or node in self.nodeconstants.wdirfilenodeids | |||||
| ): | |||||
| raise error.RevlogError( | raise error.RevlogError( | ||||
| _(b"%s: attempt to add wdir revision") % self.indexfile | _(b"%s: attempt to add wdir revision") % self.indexfile | ||||
| ) | ) | ||||
| if self._inline: | if self._inline: | ||||
| fh = ifh | fh = ifh | ||||
| else: | else: | ||||
| fh = dfh | fh = dfh | ||||
| import re | import re | ||||
| import subprocess | import subprocess | ||||
| import weakref | import weakref | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| wdirid, | |||||
| wdirrev, | wdirrev, | ||||
| ) | ) | ||||
| from .pycompat import getattr | from .pycompat import getattr | ||||
| from .thirdparty import attr | from .thirdparty import attr | ||||
| from . import ( | from . import ( | ||||
| copies as copiesmod, | copies as copiesmod, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| newdirs.append(d) | newdirs.append(d) | ||||
| dirs[:] = newdirs | dirs[:] = newdirs | ||||
| def binnode(ctx): | def binnode(ctx): | ||||
| """Return binary node id for a given basectx""" | """Return binary node id for a given basectx""" | ||||
| node = ctx.node() | node = ctx.node() | ||||
| if node is None: | if node is None: | ||||
| return wdirid | return ctx.repo().nodeconstants.wdirid | ||||
| return node | return node | ||||
| def intrev(ctx): | def intrev(ctx): | ||||
| """Return integer for a given basectx that can be used in comparison or | """Return integer for a given basectx that can be used in comparison or | ||||
| arithmetic operation""" | arithmetic operation""" | ||||
| rev = ctx.rev() | rev = ctx.rev() | ||||
| if rev is None: | if rev is None: | ||||
| for rep in replacements: | for rep in replacements: | ||||
| allreplaced.extend(rep) | allreplaced.extend(rep) | ||||
| roots = list( | roots = list( | ||||
| unfi.set(b'max((::%n) - %ln)', oldnode, allreplaced) | unfi.set(b'max((::%n) - %ln)', oldnode, allreplaced) | ||||
| ) | ) | ||||
| if roots: | if roots: | ||||
| newnode = roots[0].node() | newnode = roots[0].node() | ||||
| else: | else: | ||||
| newnode = nullid | newnode = repo.nullid | ||||
| else: | else: | ||||
| newnode = newnodes[0] | newnode = newnodes[0] | ||||
| moves[oldnode] = newnode | moves[oldnode] = newnode | ||||
| allnewnodes = [n for ns in replacements.values() for n in ns] | allnewnodes = [n for ns in replacements.values() for n in ns] | ||||
| toretract = {} | toretract = {} | ||||
| toadvance = {} | toadvance = {} | ||||
| if fixphase: | if fixphase: | ||||
| A matcher can be provided as an optimization. It is probably a bug to pass | A matcher can be provided as an optimization. It is probably a bug to pass | ||||
| a matcher that doesn't match all the differences between the parent of the | a matcher that doesn't match all the differences between the parent of the | ||||
| working copy and newctx. | working copy and newctx. | ||||
| """ | """ | ||||
| oldctx = repo[b'.'] | oldctx = repo[b'.'] | ||||
| ds = repo.dirstate | ds = repo.dirstate | ||||
| copies = dict(ds.copies()) | copies = dict(ds.copies()) | ||||
| ds.setparents(newctx.node(), nullid) | ds.setparents(newctx.node(), repo.nullid) | ||||
| s = newctx.status(oldctx, match=match) | s = newctx.status(oldctx, match=match) | ||||
| for f in s.modified: | for f in s.modified: | ||||
| if ds[f] == b'r': | if ds[f] == b'r': | ||||
| # modified + removed -> removed | # modified + removed -> removed | ||||
| continue | continue | ||||
| ds.normallookup(f) | ds.normallookup(f) | ||||
| for f in s.added: | for f in s.added: | ||||
| """ | """ | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import random | import random | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import nullrev | ||||
| nullid, | |||||
| nullrev, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| error, | error, | ||||
| policy, | policy, | ||||
| util, | util, | ||||
| ) | ) | ||||
| def _updatesample(revs, heads, sample, parentfn, quicksamplesize=0): | def _updatesample(revs, heads, sample, parentfn, quicksamplesize=0): | ||||
| ) | ) | ||||
| srvheadhashes, yesno = fheads.result(), fknown.result() | srvheadhashes, yesno = fheads.result(), fknown.result() | ||||
| if audit is not None: | if audit is not None: | ||||
| audit[b'total-roundtrips'] = 1 | audit[b'total-roundtrips'] = 1 | ||||
| if cl.tiprev() == nullrev: | if cl.tiprev() == nullrev: | ||||
| if srvheadhashes != [nullid]: | if srvheadhashes != [cl.nullid]: | ||||
| return [nullid], True, srvheadhashes | return [cl.nullid], True, srvheadhashes | ||||
| return [nullid], False, [] | return [cl.nullid], False, [] | ||||
| else: | else: | ||||
| # we still need the remote head for the function return | # we still need the remote head for the function return | ||||
| with remote.commandexecutor() as e: | with remote.commandexecutor() as e: | ||||
| fheads = e.callcommand(b'heads', {}) | fheads = e.callcommand(b'heads', {}) | ||||
| srvheadhashes = fheads.result() | srvheadhashes = fheads.result() | ||||
| # start actual discovery (we note this before the next "if" for | # start actual discovery (we note this before the next "if" for | ||||
| # compatibility reasons) | # compatibility reasons) | ||||
| ui.status(_(b"searching for changes\n")) | ui.status(_(b"searching for changes\n")) | ||||
| knownsrvheads = [] # revnos of remote heads that are known locally | knownsrvheads = [] # revnos of remote heads that are known locally | ||||
| for node in srvheadhashes: | for node in srvheadhashes: | ||||
| if node == nullid: | if node == cl.nullid: | ||||
| continue | continue | ||||
| try: | try: | ||||
| knownsrvheads.append(clrev(node)) | knownsrvheads.append(clrev(node)) | ||||
| # Catches unknown and filtered nodes. | # Catches unknown and filtered nodes. | ||||
| except error.LookupError: | except error.LookupError: | ||||
| continue | continue | ||||
| b' %d roundtrips in %.4fs\n' | b' %d roundtrips in %.4fs\n' | ||||
| ) | ) | ||||
| missing = set(result) - set(knownsrvheads) | missing = set(result) - set(knownsrvheads) | ||||
| ui.log(b'discovery', msg, len(result), len(missing), roundtrips, elapsed) | ui.log(b'discovery', msg, len(result), len(missing), roundtrips, elapsed) | ||||
| if audit is not None: | if audit is not None: | ||||
| audit[b'total-roundtrips'] = roundtrips | audit[b'total-roundtrips'] = roundtrips | ||||
| if not result and srvheadhashes != [nullid]: | if not result and srvheadhashes != [cl.nullid]: | ||||
| if abortwhenunrelated: | if abortwhenunrelated: | ||||
| raise error.Abort(_(b"repository is unrelated")) | raise error.Abort(_(b"repository is unrelated")) | ||||
| else: | else: | ||||
| ui.warn(_(b"warning: repository is unrelated\n")) | ui.warn(_(b"warning: repository is unrelated\n")) | ||||
| return ( | return ( | ||||
| {nullid}, | {cl.nullid}, | ||||
| True, | True, | ||||
| srvheadhashes, | srvheadhashes, | ||||
| ) | ) | ||||
| anyincoming = srvheadhashes != [nullid] | anyincoming = srvheadhashes != [cl.nullid] | ||||
| result = {clnode(r) for r in result} | result = {clnode(r) for r in result} | ||||
| return result, anyincoming, srvheadhashes | return result, anyincoming, srvheadhashes | ||||
| import errno | import errno | ||||
| import itertools | import itertools | ||||
| import stat | import stat | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| bookmarks, | bookmarks, | ||||
| bundle2, | bundle2, | ||||
| changegroup, | changegroup, | ||||
| cmdutil, | cmdutil, | ||||
| discovery, | discovery, | ||||
| _(b"unresolved conflicts, can't continue"), | _(b"unresolved conflicts, can't continue"), | ||||
| hint=_(b"see 'hg resolve', then 'hg unshelve --continue'"), | hint=_(b"see 'hg resolve', then 'hg unshelve --continue'"), | ||||
| ) | ) | ||||
| shelvectx = repo[state.parents[1]] | shelvectx = repo[state.parents[1]] | ||||
| pendingctx = state.pendingctx | pendingctx = state.pendingctx | ||||
| with repo.dirstate.parentchange(): | with repo.dirstate.parentchange(): | ||||
| repo.setparents(state.pendingctx.node(), nullid) | repo.setparents(state.pendingctx.node(), repo.nullid) | ||||
| repo.dirstate.write(repo.currenttransaction()) | repo.dirstate.write(repo.currenttransaction()) | ||||
| targetphase = phases.internal | targetphase = phases.internal | ||||
| if not phases.supportinternal(repo): | if not phases.supportinternal(repo): | ||||
| targetphase = phases.secret | targetphase = phases.secret | ||||
| overrides = {(b'phases', b'new-commit'): targetphase} | overrides = {(b'phases', b'new-commit'): targetphase} | ||||
| with repo.ui.configoverride(overrides, b'unshelve'): | with repo.ui.configoverride(overrides, b'unshelve'): | ||||
| with repo.dirstate.parentchange(): | with repo.dirstate.parentchange(): | ||||
| repo.setparents(state.parents[0], nullid) | repo.setparents(state.parents[0], repo.nullid) | ||||
| newnode, ispartialunshelve = _createunshelvectx( | newnode, ispartialunshelve = _createunshelvectx( | ||||
| ui, repo, shelvectx, basename, interactive, opts | ui, repo, shelvectx, basename, interactive, opts | ||||
| ) | ) | ||||
| if newnode is None: | if newnode is None: | ||||
| shelvectx = state.pendingctx | shelvectx = state.pendingctx | ||||
| msg = _( | msg = _( | ||||
| b'note: unshelved changes already existed ' | b'note: unshelved changes already existed ' | ||||
| branchtorestore, | branchtorestore, | ||||
| opts.get(b'keep'), | opts.get(b'keep'), | ||||
| activebookmark, | activebookmark, | ||||
| interactive, | interactive, | ||||
| ) | ) | ||||
| raise error.ConflictResolutionRequired(b'unshelve') | raise error.ConflictResolutionRequired(b'unshelve') | ||||
| with repo.dirstate.parentchange(): | with repo.dirstate.parentchange(): | ||||
| repo.setparents(tmpwctx.node(), nullid) | repo.setparents(tmpwctx.node(), repo.nullid) | ||||
| newnode, ispartialunshelve = _createunshelvectx( | newnode, ispartialunshelve = _createunshelvectx( | ||||
| ui, repo, shelvectx, basename, interactive, opts | ui, repo, shelvectx, basename, interactive, opts | ||||
| ) | ) | ||||
| if newnode is None: | if newnode is None: | ||||
| shelvectx = tmpwctx | shelvectx = tmpwctx | ||||
| msg = _( | msg = _( | ||||
| b'note: unshelved changes already existed ' | b'note: unshelved changes already existed ' | ||||
| # sparse.py - functionality for sparse checkouts | # sparse.py - functionality for sparse checkouts | ||||
| # | # | ||||
| # Copyright 2014 Facebook, Inc. | # Copyright 2014 Facebook, Inc. | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import os | import os | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import hex | ||||
| hex, | |||||
| nullid, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| error, | error, | ||||
| match as matchmod, | match as matchmod, | ||||
| merge as mergemod, | merge as mergemod, | ||||
| mergestate as mergestatemod, | mergestate as mergestatemod, | ||||
| pathutil, | pathutil, | ||||
| pycompat, | pycompat, | ||||
| requirements, | requirements, | ||||
| """Determine the active sparse config rules. | """Determine the active sparse config rules. | ||||
| Rules are constructed by reading the current sparse config and bringing in | Rules are constructed by reading the current sparse config and bringing in | ||||
| referenced profiles from parents of the working directory. | referenced profiles from parents of the working directory. | ||||
| """ | """ | ||||
| revs = [ | revs = [ | ||||
| repo.changelog.rev(node) | repo.changelog.rev(node) | ||||
| for node in repo.dirstate.parents() | for node in repo.dirstate.parents() | ||||
| if node != nullid | if node != repo.nullid | ||||
| ] | ] | ||||
| allincludes = set() | allincludes = set() | ||||
| allexcludes = set() | allexcludes = set() | ||||
| allprofiles = set() | allprofiles = set() | ||||
| for rev in revs: | for rev in revs: | ||||
| includes, excludes, profiles = patternsforrev(repo, rev) | includes, excludes, profiles = patternsforrev(repo, rev) | ||||
| # If sparse isn't enabled, sparse matcher matches everything. | # If sparse isn't enabled, sparse matcher matches everything. | ||||
| if not enabled: | if not enabled: | ||||
| return matchmod.always() | return matchmod.always() | ||||
| if not revs or revs == [None]: | if not revs or revs == [None]: | ||||
| revs = [ | revs = [ | ||||
| repo.changelog.rev(node) | repo.changelog.rev(node) | ||||
| for node in repo.dirstate.parents() | for node in repo.dirstate.parents() | ||||
| if node != nullid | if node != repo.nullid | ||||
| ] | ] | ||||
| signature = configsignature(repo, includetemp=includetemp) | signature = configsignature(repo, includetemp=includetemp) | ||||
| key = b'%s %s' % (signature, b' '.join(map(pycompat.bytestr, revs))) | key = b'%s %s' % (signature, b' '.join(map(pycompat.bytestr, revs))) | ||||
| result = repo._sparsematchercache.get(key) | result = repo._sparsematchercache.get(key) | ||||
| if result: | if result: | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .pycompat import getattr | from .pycompat import getattr | ||||
| from .node import nullid | |||||
| from . import ( | from . import ( | ||||
| bookmarks as bookmarksmod, | bookmarks as bookmarksmod, | ||||
| cmdutil, | cmdutil, | ||||
| error, | error, | ||||
| hg, | hg, | ||||
| lock as lockmod, | lock as lockmod, | ||||
| mergestate as mergestatemod, | mergestate as mergestatemod, | ||||
| pycompat, | pycompat, | ||||
| def _findupdatetarget(repo, nodes): | def _findupdatetarget(repo, nodes): | ||||
| unode, p2 = repo.changelog.parents(nodes[0]) | unode, p2 = repo.changelog.parents(nodes[0]) | ||||
| currentbranch = repo[None].branch() | currentbranch = repo[None].branch() | ||||
| if ( | if ( | ||||
| util.safehasattr(repo, b'mq') | util.safehasattr(repo, b'mq') | ||||
| and p2 != nullid | and p2 != repo.nullid | ||||
| and p2 in [x.node for x in repo.mq.applied] | and p2 in [x.node for x in repo.mq.applied] | ||||
| ): | ): | ||||
| unode = p2 | unode = p2 | ||||
| elif currentbranch != repo[unode].branch(): | elif currentbranch != repo[unode].branch(): | ||||
| pwdir = b'parents(wdir())' | pwdir = b'parents(wdir())' | ||||
| revset = b'max(((parents(%ln::%r) + %r) - %ln::%r) and branch(%s))' | revset = b'max(((parents(%ln::%r) + %r) - %ln::%r) and branch(%s))' | ||||
| branchtarget = repo.revs( | branchtarget = repo.revs( | ||||
| revset, nodes, pwdir, pwdir, nodes, pwdir, currentbranch | revset, nodes, pwdir, pwdir, nodes, pwdir, currentbranch | ||||
| descendants = set(cl.descendants(revs)) | descendants = set(cl.descendants(revs)) | ||||
| strippedrevs = revs.union(descendants) | strippedrevs = revs.union(descendants) | ||||
| roots = revs.difference(descendants) | roots = revs.difference(descendants) | ||||
| # if one of the wdir parent is stripped we'll need | # if one of the wdir parent is stripped we'll need | ||||
| # to update away to an earlier revision | # to update away to an earlier revision | ||||
| update = any( | update = any( | ||||
| p != nullid and cl.rev(p) in strippedrevs | p != repo.nullid and cl.rev(p) in strippedrevs | ||||
| for p in repo.dirstate.parents() | for p in repo.dirstate.parents() | ||||
| ) | ) | ||||
| rootnodes = {cl.node(r) for r in roots} | rootnodes = {cl.node(r) for r in roots} | ||||
| q = getattr(repo, 'mq', None) | q = getattr(repo, 'mq', None) | ||||
| if q is not None and q.applied: | if q is not None and q.applied: | ||||
| # refresh queue state if we're about to strip | # refresh queue state if we're about to strip | ||||
| import sys | import sys | ||||
| import tarfile | import tarfile | ||||
| import xml.dom.minidom | import xml.dom.minidom | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| short, | short, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| cmdutil, | cmdutil, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| exchange, | exchange, | ||||
| logcmdutil, | logcmdutil, | ||||
| def phase(self, state): | def phase(self, state): | ||||
| return self._repo[state or b'.'].phase() | return self._repo[state or b'.'].phase() | ||||
| @annotatesubrepoerror | @annotatesubrepoerror | ||||
| def remove(self): | def remove(self): | ||||
| # we can't fully delete the repository as it may contain | # we can't fully delete the repository as it may contain | ||||
| # local-only history | # local-only history | ||||
| self.ui.note(_(b'removing subrepo %s\n') % subrelpath(self)) | self.ui.note(_(b'removing subrepo %s\n') % subrelpath(self)) | ||||
| hg.clean(self._repo, nullid, False) | hg.clean(self._repo, self._repo.nullid, False) | ||||
| def _get(self, state): | def _get(self, state): | ||||
| source, revision, kind = state | source, revision, kind = state | ||||
| parentrepo = self._repo._subparent | parentrepo = self._repo._subparent | ||||
| if revision in self._repo.unfiltered(): | if revision in self._repo.unfiltered(): | ||||
| # Allow shared subrepos tracked at null to setup the sharedpath | # Allow shared subrepos tracked at null to setup the sharedpath | ||||
| if len(self._repo) != 0 or not parentrepo.shared(): | if len(self._repo) != 0 or not parentrepo.shared(): | ||||
| # merged tags file | # merged tags file | ||||
| # - sort the "tag blocks" according to their associated number line | # - sort the "tag blocks" according to their associated number line | ||||
| # - put blocks whose nodes come all from p2 first | # - put blocks whose nodes come all from p2 first | ||||
| # - write the tag blocks in the sorted order | # - write the tag blocks in the sorted order | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | |||||
| nullhex, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| tags as tagsmod, | tags as tagsmod, | ||||
| util, | util, | ||||
| ) | ) | ||||
| def readtagsformerge(ui, repo, lines, fn=b'', keeplinenums=False): | def readtagsformerge(ui, repo, lines, fn=b'', keeplinenums=False): | ||||
| """read the .hgtags file into a structure that is suitable for merging | """read the .hgtags file into a structure that is suitable for merging | ||||
| # recover the list of "lost tags" (i.e. those that were found on the base | # recover the list of "lost tags" (i.e. those that were found on the base | ||||
| # revision but not on one of the revisions being merged) | # revision but not on one of the revisions being merged) | ||||
| basetagset = set(basetags) | basetagset = set(basetags) | ||||
| for n, pntags in enumerate((p1tags, p2tags)): | for n, pntags in enumerate((p1tags, p2tags)): | ||||
| pntagset = set(pntags) | pntagset = set(pntags) | ||||
| pnlosttagset = basetagset - pntagset | pnlosttagset = basetagset - pntagset | ||||
| for t in pnlosttagset: | for t in pnlosttagset: | ||||
| pntags[t] = basetags[t] | pntags[t] = basetags[t] | ||||
| if pntags[t][-1][0] != nullhex: | if pntags[t][-1][0] != repo.nodeconstants.nullhex: | ||||
| pntags[t].append([nullhex, None]) | pntags[t].append([repo.nodeconstants.nullhex, None]) | ||||
| conflictedtags = [] # for reporting purposes | conflictedtags = [] # for reporting purposes | ||||
| mergedtags = util.sortdict(p1tags) | mergedtags = util.sortdict(p1tags) | ||||
| # sortdict does not implement iteritems() | # sortdict does not implement iteritems() | ||||
| for tname, p2nodes in p2tags.items(): | for tname, p2nodes in p2tags.items(): | ||||
| if tname not in mergedtags: | if tname not in mergedtags: | ||||
| mergedtags[tname] = p2nodes | mergedtags[tname] = p2nodes | ||||
| continue | continue | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import errno | import errno | ||||
| import io | import io | ||||
| from .node import ( | from .node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| short, | short, | ||||
| ) | ) | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from . import ( | from . import ( | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| match as matchmod, | match as matchmod, | ||||
| unfi = repo.unfiltered() | unfi = repo.unfiltered() | ||||
| tonode = unfi.changelog.node | tonode = unfi.changelog.node | ||||
| nodes = [tonode(r) for r in revs] | nodes = [tonode(r) for r in revs] | ||||
| fnodes = _getfnodes(ui, repo, nodes) | fnodes = _getfnodes(ui, repo, nodes) | ||||
| fnodes = _filterfnodes(fnodes, nodes) | fnodes = _filterfnodes(fnodes, nodes) | ||||
| return fnodes | return fnodes | ||||
| def _nulltonone(value): | def _nulltonone(repo, value): | ||||
| """convert nullid to None | """convert nullid to None | ||||
| For tag value, nullid means "deleted". This small utility function helps | For tag value, nullid means "deleted". This small utility function helps | ||||
| translating that to None.""" | translating that to None.""" | ||||
| if value == nullid: | if value == repo.nullid: | ||||
| return None | return None | ||||
| return value | return value | ||||
| def difftags(ui, repo, oldfnodes, newfnodes): | def difftags(ui, repo, oldfnodes, newfnodes): | ||||
| """list differences between tags expressed in two set of file-nodes | """list differences between tags expressed in two set of file-nodes | ||||
| The list contains entries in the form: (tagname, oldvalue, new value). | The list contains entries in the form: (tagname, oldvalue, new value). | ||||
| None is used to expressed missing value: | None is used to expressed missing value: | ||||
| ('foo', None, 'abcd') is a new tag, | ('foo', None, 'abcd') is a new tag, | ||||
| ('bar', 'ef01', None) is a deletion, | ('bar', 'ef01', None) is a deletion, | ||||
| ('baz', 'abcd', 'ef01') is a tag movement. | ('baz', 'abcd', 'ef01') is a tag movement. | ||||
| """ | """ | ||||
| if oldfnodes == newfnodes: | if oldfnodes == newfnodes: | ||||
| return [] | return [] | ||||
| oldtags = _tagsfromfnodes(ui, repo, oldfnodes) | oldtags = _tagsfromfnodes(ui, repo, oldfnodes) | ||||
| newtags = _tagsfromfnodes(ui, repo, newfnodes) | newtags = _tagsfromfnodes(ui, repo, newfnodes) | ||||
| # list of (tag, old, new): None means missing | # list of (tag, old, new): None means missing | ||||
| entries = [] | entries = [] | ||||
| for tag, (new, __) in newtags.items(): | for tag, (new, __) in newtags.items(): | ||||
| new = _nulltonone(new) | new = _nulltonone(repo, new) | ||||
| old, __ = oldtags.pop(tag, (None, None)) | old, __ = oldtags.pop(tag, (None, None)) | ||||
| old = _nulltonone(old) | old = _nulltonone(repo, old) | ||||
| if old != new: | if old != new: | ||||
| entries.append((tag, old, new)) | entries.append((tag, old, new)) | ||||
| # handle deleted tags | # handle deleted tags | ||||
| for tag, (old, __) in oldtags.items(): | for tag, (old, __) in oldtags.items(): | ||||
| old = _nulltonone(old) | old = _nulltonone(repo, old) | ||||
| if old is not None: | if old is not None: | ||||
| entries.append((tag, old, None)) | entries.append((tag, old, None)) | ||||
| entries.sort() | entries.sort() | ||||
| return entries | return entries | ||||
| def writediff(fp, difflist): | def writediff(fp, difflist): | ||||
| """write tags diff information to a file. | """write tags diff information to a file. | ||||
| if cachefile: | if cachefile: | ||||
| cachefile.close() # ignore rest of file | cachefile.close() # ignore rest of file | ||||
| valid = (tiprev, tipnode, scmutil.filteredhash(repo, tiprev)) | valid = (tiprev, tipnode, scmutil.filteredhash(repo, tiprev)) | ||||
| repoheads = repo.heads() | repoheads = repo.heads() | ||||
| # Case 2 (uncommon): empty repo; get out quickly and don't bother | # Case 2 (uncommon): empty repo; get out quickly and don't bother | ||||
| # writing an empty cache. | # writing an empty cache. | ||||
| if repoheads == [nullid]: | if repoheads == [repo.nullid]: | ||||
| return ([], {}, valid, {}, False) | return ([], {}, valid, {}, False) | ||||
| # Case 3 (uncommon): cache file missing or empty. | # Case 3 (uncommon): cache file missing or empty. | ||||
| # Case 4 (uncommon): tip rev decreased. This should only happen | # Case 4 (uncommon): tip rev decreased. This should only happen | ||||
| # when we're called from localrepository.destroyed(). Refresh the | # when we're called from localrepository.destroyed(). Refresh the | ||||
| # cache so future invocations will not see disappeared heads in the | # cache so future invocations will not see disappeared heads in the | ||||
| # cache. | # cache. | ||||
| starttime = util.timer() | starttime = util.timer() | ||||
| fnodescache = hgtagsfnodescache(repo.unfiltered()) | fnodescache = hgtagsfnodescache(repo.unfiltered()) | ||||
| cachefnode = {} | cachefnode = {} | ||||
| validated_fnodes = set() | validated_fnodes = set() | ||||
| unknown_entries = set() | unknown_entries = set() | ||||
| for node in nodes: | for node in nodes: | ||||
| fnode = fnodescache.getfnode(node) | fnode = fnodescache.getfnode(node) | ||||
| flog = repo.file(b'.hgtags') | flog = repo.file(b'.hgtags') | ||||
| if fnode != nullid: | if fnode != repo.nullid: | ||||
| if fnode not in validated_fnodes: | if fnode not in validated_fnodes: | ||||
| if flog.hasnode(fnode): | if flog.hasnode(fnode): | ||||
| validated_fnodes.add(fnode) | validated_fnodes.add(fnode) | ||||
| else: | else: | ||||
| unknown_entries.add(node) | unknown_entries.add(node) | ||||
| cachefnode[node] = fnode | cachefnode[node] = fnode | ||||
| if unknown_entries: | if unknown_entries: | ||||
| fixed_nodemap = fnodescache.refresh_invalid_nodes(unknown_entries) | fixed_nodemap = fnodescache.refresh_invalid_nodes(unknown_entries) | ||||
| for node, fnode in pycompat.iteritems(fixed_nodemap): | for node, fnode in pycompat.iteritems(fixed_nodemap): | ||||
| if fnode != nullid: | if fnode != repo.nullid: | ||||
| cachefnode[node] = fnode | cachefnode[node] = fnode | ||||
| fnodescache.write() | fnodescache.write() | ||||
| duration = util.timer() - starttime | duration = util.timer() - starttime | ||||
| ui.log( | ui.log( | ||||
| b'tagscache', | b'tagscache', | ||||
| b'%d/%d cache hits/lookups in %0.4f seconds\n', | b'%d/%d cache hits/lookups in %0.4f seconds\n', | ||||
| fp.write(b'\n') | fp.write(b'\n') | ||||
| for name in names: | for name in names: | ||||
| if munge: | if munge: | ||||
| m = munge(name) | m = munge(name) | ||||
| else: | else: | ||||
| m = name | m = name | ||||
| if repo._tagscache.tagtypes and name in repo._tagscache.tagtypes: | if repo._tagscache.tagtypes and name in repo._tagscache.tagtypes: | ||||
| old = repo.tags().get(name, nullid) | old = repo.tags().get(name, repo.nullid) | ||||
| fp.write(b'%s %s\n' % (hex(old), m)) | fp.write(b'%s %s\n' % (hex(old), m)) | ||||
| fp.write(b'%s %s\n' % (hex(node), m)) | fp.write(b'%s %s\n' % (hex(node), m)) | ||||
| fp.close() | fp.close() | ||||
| prevtags = b'' | prevtags = b'' | ||||
| if local: | if local: | ||||
| try: | try: | ||||
| fp = repo.vfs(b'localtags', b'r+') | fp = repo.vfs(b'localtags', b'r+') | ||||
| Otherwise, the filenode will be computed and returned unless | Otherwise, the filenode will be computed and returned unless | ||||
| "computemissing" is False. In that case, None will be returned if | "computemissing" is False. In that case, None will be returned if | ||||
| the entry is missing or False if the entry is invalid without | the entry is missing or False if the entry is invalid without | ||||
| any potentially expensive computation being performed. | any potentially expensive computation being performed. | ||||
| If an .hgtags does not exist at the specified revision, nullid is | If an .hgtags does not exist at the specified revision, nullid is | ||||
| returned. | returned. | ||||
| """ | """ | ||||
| if node == nullid: | if node == self._repo.nullid: | ||||
| return nullid | return node | ||||
| ctx = self._repo[node] | ctx = self._repo[node] | ||||
| rev = ctx.rev() | rev = ctx.rev() | ||||
| self.lookupcount += 1 | self.lookupcount += 1 | ||||
| offset = rev * _fnodesrecsize | offset = rev * _fnodesrecsize | ||||
| record = b'%s' % self._raw[offset : offset + _fnodesrecsize] | record = b'%s' % self._raw[offset : offset + _fnodesrecsize] | ||||
| if fnode is None: | if fnode is None: | ||||
| fnode = p1fnode | fnode = p1fnode | ||||
| if fnode is None: | if fnode is None: | ||||
| # Populate missing entry. | # Populate missing entry. | ||||
| try: | try: | ||||
| fnode = ctx.filenode(b'.hgtags') | fnode = ctx.filenode(b'.hgtags') | ||||
| except error.LookupError: | except error.LookupError: | ||||
| # No .hgtags file on this revision. | # No .hgtags file on this revision. | ||||
| fnode = nullid | fnode = self._repo.nullid | ||||
| return fnode | return fnode | ||||
| def setfnode(self, node, fnode): | def setfnode(self, node, fnode): | ||||
| """Set the .hgtags filenode for a given changeset.""" | """Set the .hgtags filenode for a given changeset.""" | ||||
| assert len(fnode) == 20 | assert len(fnode) == 20 | ||||
| ctx = self._repo[node] | ctx = self._repo[node] | ||||
| # Do a lookup first to avoid writing if nothing has changed. | # Do a lookup first to avoid writing if nothing has changed. | ||||
| # templatefuncs.py - common template functions | # templatefuncs.py - common template functions | ||||
| # | # | ||||
| # Copyright 2005, 2006 Olivia Mackall <olivia@selenic.com> | # Copyright 2005, 2006 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import re | import re | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import bin | ||||
| bin, | |||||
| wdirid, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| color, | color, | ||||
| dagop, | dagop, | ||||
| diffutil, | diffutil, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| minirst, | minirst, | ||||
| obsutil, | obsutil, | ||||
| try: | try: | ||||
| node = bin(hexnode) | node = bin(hexnode) | ||||
| except TypeError: | except TypeError: | ||||
| return hexnode | return hexnode | ||||
| else: | else: | ||||
| try: | try: | ||||
| node = scmutil.resolvehexnodeidprefix(repo, hexnode) | node = scmutil.resolvehexnodeidprefix(repo, hexnode) | ||||
| except error.WdirUnsupported: | except error.WdirUnsupported: | ||||
| node = wdirid | node = repo.nodeconstants.wdirid | ||||
| except error.LookupError: | except error.LookupError: | ||||
| return hexnode | return hexnode | ||||
| if not node: | if not node: | ||||
| return hexnode | return hexnode | ||||
| cache = context.resource(mapping, b'cache') | cache = context.resource(mapping, b'cache') | ||||
| try: | try: | ||||
| return scmutil.shortesthexnodeidprefix(repo, node, minlength, cache) | return scmutil.shortesthexnodeidprefix(repo, node, minlength, cache) | ||||
| except error.RepoLookupError: | except error.RepoLookupError: | ||||
| # templatekw.py - common changeset template keywords | # templatekw.py - common changeset template keywords | ||||
| # | # | ||||
| # Copyright 2005-2009 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2009 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| wdirid, | |||||
| wdirrev, | wdirrev, | ||||
| ) | ) | ||||
| from . import ( | from . import ( | ||||
| diffutil, | diffutil, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| hbisect, | hbisect, | ||||
| def getgraphnode(repo, ctx, cache): | def getgraphnode(repo, ctx, cache): | ||||
| return getgraphnodecurrent(repo, ctx, cache) or getgraphnodesymbol(ctx) | return getgraphnodecurrent(repo, ctx, cache) or getgraphnodesymbol(ctx) | ||||
| def getgraphnodecurrent(repo, ctx, cache): | def getgraphnodecurrent(repo, ctx, cache): | ||||
| wpnodes = repo.dirstate.parents() | wpnodes = repo.dirstate.parents() | ||||
| if wpnodes[1] == nullid: | if wpnodes[1] == repo.nullid: | ||||
| wpnodes = wpnodes[:1] | wpnodes = wpnodes[:1] | ||||
| if ctx.node() in wpnodes: | if ctx.node() in wpnodes: | ||||
| return b'@' | return b'@' | ||||
| else: | else: | ||||
| merge_nodes = cache.get(b'merge_nodes') | merge_nodes = cache.get(b'merge_nodes') | ||||
| if merge_nodes is None: | if merge_nodes is None: | ||||
| from . import mergestate as mergestatemod | from . import mergestate as mergestatemod | ||||
| @templatekeyword(b'manifest', requires={b'repo', b'ctx'}) | @templatekeyword(b'manifest', requires={b'repo', b'ctx'}) | ||||
| def showmanifest(context, mapping): | def showmanifest(context, mapping): | ||||
| repo = context.resource(mapping, b'repo') | repo = context.resource(mapping, b'repo') | ||||
| ctx = context.resource(mapping, b'ctx') | ctx = context.resource(mapping, b'ctx') | ||||
| mnode = ctx.manifestnode() | mnode = ctx.manifestnode() | ||||
| if mnode is None: | if mnode is None: | ||||
| mnode = wdirid | mnode = repo.nodeconstants.wdirid | ||||
| mrev = wdirrev | mrev = wdirrev | ||||
| mhex = repo.nodeconstants.wdirhex | |||||
| else: | else: | ||||
| mrev = repo.manifestlog.rev(mnode) | mrev = repo.manifestlog.rev(mnode) | ||||
| mhex = hex(mnode) | mhex = hex(mnode) | ||||
| mapping = context.overlaymap(mapping, {b'rev': mrev, b'node': mhex}) | mapping = context.overlaymap(mapping, {b'rev': mrev, b'node': mhex}) | ||||
| f = context.process(b'manifest', mapping) | f = context.process(b'manifest', mapping) | ||||
| return templateutil.hybriditem( | return templateutil.hybriditem( | ||||
| f, None, f, lambda x: {b'rev': mrev, b'node': mhex} | f, None, f, lambda x: {b'rev': mrev, b'node': mhex} | ||||
| ) | ) | ||||
| @templatekeyword(b'obsfate', requires={b'ui', b'repo', b'ctx'}) | @templatekeyword(b'obsfate', requires={b'ui', b'repo', b'ctx'}) | ||||
| # storage.py - Testing of storage primitives. | # storage.py - Testing of storage primitives. | ||||
| # | # | ||||
| # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> | # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import unittest | import unittest | ||||
| from ..node import ( | from ..node import ( | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| ) | ) | ||||
| from ..pycompat import getattr | from ..pycompat import getattr | ||||
| from .. import ( | from .. import ( | ||||
| error, | error, | ||||
| mdiff, | mdiff, | ||||
| ) | ) | ||||
| from ..interfaces import repository | from ..interfaces import repository | ||||
| gen = iter(f) | gen = iter(f) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| self.assertFalse(f.hasnode(None)) | self.assertFalse(f.hasnode(None)) | ||||
| self.assertFalse(f.hasnode(0)) | self.assertFalse(f.hasnode(0)) | ||||
| self.assertFalse(f.hasnode(nullrev)) | self.assertFalse(f.hasnode(nullrev)) | ||||
| self.assertFalse(f.hasnode(nullid)) | self.assertFalse(f.hasnode(f.nullid)) | ||||
| self.assertFalse(f.hasnode(b'0')) | self.assertFalse(f.hasnode(b'0')) | ||||
| self.assertFalse(f.hasnode(b'a' * 20)) | self.assertFalse(f.hasnode(b'a' * 20)) | ||||
| # revs() should evaluate to an empty list. | # revs() should evaluate to an empty list. | ||||
| self.assertEqual(list(f.revs()), []) | self.assertEqual(list(f.revs()), []) | ||||
| revs = iter(f.revs()) | revs = iter(f.revs()) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(revs) | next(revs) | ||||
| self.assertEqual(list(f.revs(start=20)), []) | self.assertEqual(list(f.revs(start=20)), []) | ||||
| # parents() and parentrevs() work with nullid/nullrev. | # parents() and parentrevs() work with f.nullid/nullrev. | ||||
| self.assertEqual(f.parents(nullid), (nullid, nullid)) | self.assertEqual(f.parents(f.nullid), (f.nullid, f.nullid)) | ||||
| self.assertEqual(f.parentrevs(nullrev), (nullrev, nullrev)) | self.assertEqual(f.parentrevs(nullrev), (nullrev, nullrev)) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.parents(b'\x01' * 20) | f.parents(b'\x01' * 20) | ||||
| for i in range(-5, 5): | for i in range(-5, 5): | ||||
| if i == nullrev: | if i == nullrev: | ||||
| continue | continue | ||||
| with self.assertRaises(IndexError): | with self.assertRaises(IndexError): | ||||
| f.parentrevs(i) | f.parentrevs(i) | ||||
| # nullid/nullrev lookup always works. | # f.nullid/nullrev lookup always works. | ||||
| self.assertEqual(f.rev(nullid), nullrev) | self.assertEqual(f.rev(f.nullid), nullrev) | ||||
| self.assertEqual(f.node(nullrev), nullid) | self.assertEqual(f.node(nullrev), f.nullid) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.rev(b'\x01' * 20) | f.rev(b'\x01' * 20) | ||||
| for i in range(-5, 5): | for i in range(-5, 5): | ||||
| if i == nullrev: | if i == nullrev: | ||||
| continue | continue | ||||
| with self.assertRaises(IndexError): | with self.assertRaises(IndexError): | ||||
| f.node(i) | f.node(i) | ||||
| self.assertEqual(f.lookup(nullid), nullid) | self.assertEqual(f.lookup(f.nullid), f.nullid) | ||||
| self.assertEqual(f.lookup(nullrev), nullid) | self.assertEqual(f.lookup(nullrev), f.nullid) | ||||
| self.assertEqual(f.lookup(hex(nullid)), nullid) | self.assertEqual(f.lookup(hex(f.nullid)), f.nullid) | ||||
| self.assertEqual(f.lookup(b'%d' % nullrev), nullid) | self.assertEqual(f.lookup(b'%d' % nullrev), f.nullid) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.lookup(b'badvalue') | f.lookup(b'badvalue') | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.lookup(hex(nullid)[0:12]) | f.lookup(hex(f.nullid)[0:12]) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.lookup(b'-2') | f.lookup(b'-2') | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.lookup(b'0') | f.lookup(b'0') | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| for i in range(-5, 5): | for i in range(-5, 5): | ||||
| if i == nullrev: | if i == nullrev: | ||||
| continue | continue | ||||
| with self.assertRaises(IndexError): | with self.assertRaises(IndexError): | ||||
| f.iscensored(i) | f.iscensored(i) | ||||
| self.assertEqual(list(f.commonancestorsheads(nullid, nullid)), []) | self.assertEqual(list(f.commonancestorsheads(f.nullid, f.nullid)), []) | ||||
| with self.assertRaises(ValueError): | with self.assertRaises(ValueError): | ||||
| self.assertEqual(list(f.descendants([])), []) | self.assertEqual(list(f.descendants([])), []) | ||||
| self.assertEqual(list(f.descendants([nullrev])), []) | self.assertEqual(list(f.descendants([nullrev])), []) | ||||
| self.assertEqual(f.heads(), [nullid]) | self.assertEqual(f.heads(), [f.nullid]) | ||||
| self.assertEqual(f.heads(nullid), [nullid]) | self.assertEqual(f.heads(f.nullid), [f.nullid]) | ||||
| self.assertEqual(f.heads(None, [nullid]), [nullid]) | self.assertEqual(f.heads(None, [f.nullid]), [f.nullid]) | ||||
| self.assertEqual(f.heads(nullid, [nullid]), [nullid]) | self.assertEqual(f.heads(f.nullid, [f.nullid]), [f.nullid]) | ||||
| self.assertEqual(f.children(nullid), []) | self.assertEqual(f.children(f.nullid), []) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.children(b'\x01' * 20) | f.children(b'\x01' * 20) | ||||
| def testsinglerevision(self): | def testsinglerevision(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node = f.add(b'initial', None, tr, 0, nullid, nullid) | node = f.add(b'initial', None, tr, 0, f.nullid, f.nullid) | ||||
| self.assertEqual(len(f), 1) | self.assertEqual(len(f), 1) | ||||
| self.assertEqual(list(f), [0]) | self.assertEqual(list(f), [0]) | ||||
| gen = iter(f) | gen = iter(f) | ||||
| self.assertEqual(next(gen), 0) | self.assertEqual(next(gen), 0) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| self.assertTrue(f.hasnode(node)) | self.assertTrue(f.hasnode(node)) | ||||
| self.assertFalse(f.hasnode(hex(node))) | self.assertFalse(f.hasnode(hex(node))) | ||||
| self.assertFalse(f.hasnode(nullrev)) | self.assertFalse(f.hasnode(nullrev)) | ||||
| self.assertFalse(f.hasnode(nullid)) | self.assertFalse(f.hasnode(f.nullid)) | ||||
| self.assertFalse(f.hasnode(node[0:12])) | self.assertFalse(f.hasnode(node[0:12])) | ||||
| self.assertFalse(f.hasnode(hex(node)[0:20])) | self.assertFalse(f.hasnode(hex(node)[0:20])) | ||||
| self.assertEqual(list(f.revs()), [0]) | self.assertEqual(list(f.revs()), [0]) | ||||
| self.assertEqual(list(f.revs(start=1)), []) | self.assertEqual(list(f.revs(start=1)), []) | ||||
| self.assertEqual(list(f.revs(start=0)), [0]) | self.assertEqual(list(f.revs(start=0)), [0]) | ||||
| self.assertEqual(list(f.revs(stop=0)), [0]) | self.assertEqual(list(f.revs(stop=0)), [0]) | ||||
| self.assertEqual(list(f.revs(stop=1)), [0]) | self.assertEqual(list(f.revs(stop=1)), [0]) | ||||
| self.assertEqual(list(f.revs(1, 1)), []) | self.assertEqual(list(f.revs(1, 1)), []) | ||||
| # TODO buggy | # TODO buggy | ||||
| self.assertEqual(list(f.revs(1, 0)), [1, 0]) | self.assertEqual(list(f.revs(1, 0)), [1, 0]) | ||||
| self.assertEqual(list(f.revs(2, 0)), [2, 1, 0]) | self.assertEqual(list(f.revs(2, 0)), [2, 1, 0]) | ||||
| self.assertEqual(f.parents(node), (nullid, nullid)) | self.assertEqual(f.parents(node), (f.nullid, f.nullid)) | ||||
| self.assertEqual(f.parentrevs(0), (nullrev, nullrev)) | self.assertEqual(f.parentrevs(0), (nullrev, nullrev)) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.parents(b'\x01' * 20) | f.parents(b'\x01' * 20) | ||||
| with self.assertRaises(IndexError): | with self.assertRaises(IndexError): | ||||
| f.parentrevs(1) | f.parentrevs(1) | ||||
| self.assertEqual(f.rev(node), 0) | self.assertEqual(f.rev(node), 0) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.rev(b'\x01' * 20) | f.rev(b'\x01' * 20) | ||||
| self.assertEqual(f.node(0), node) | self.assertEqual(f.node(0), node) | ||||
| with self.assertRaises(IndexError): | with self.assertRaises(IndexError): | ||||
| f.node(1) | f.node(1) | ||||
| self.assertEqual(f.lookup(node), node) | self.assertEqual(f.lookup(node), node) | ||||
| self.assertEqual(f.lookup(0), node) | self.assertEqual(f.lookup(0), node) | ||||
| self.assertEqual(f.lookup(-1), nullid) | self.assertEqual(f.lookup(-1), f.nullid) | ||||
| self.assertEqual(f.lookup(b'0'), node) | self.assertEqual(f.lookup(b'0'), node) | ||||
| self.assertEqual(f.lookup(hex(node)), node) | self.assertEqual(f.lookup(hex(node)), node) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.lookup(hex(node)[0:12]) | f.lookup(hex(node)[0:12]) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.lookup(-2) | f.lookup(-2) | ||||
| def testmultiplerevisions(self): | def testmultiplerevisions(self): | ||||
| fulltext0 = b'x' * 1024 | fulltext0 = b'x' * 1024 | ||||
| fulltext1 = fulltext0 + b'y' | fulltext1 = fulltext0 + b'y' | ||||
| fulltext2 = b'y' + fulltext0 + b'z' | fulltext2 = b'y' + fulltext0 + b'z' | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) | node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = f.add(fulltext1, None, tr, 1, node0, nullid) | node1 = f.add(fulltext1, None, tr, 1, node0, f.nullid) | ||||
| node2 = f.add(fulltext2, None, tr, 3, node1, nullid) | node2 = f.add(fulltext2, None, tr, 3, node1, f.nullid) | ||||
| self.assertEqual(len(f), 3) | self.assertEqual(len(f), 3) | ||||
| self.assertEqual(list(f), [0, 1, 2]) | self.assertEqual(list(f), [0, 1, 2]) | ||||
| gen = iter(f) | gen = iter(f) | ||||
| self.assertEqual(next(gen), 0) | self.assertEqual(next(gen), 0) | ||||
| self.assertEqual(next(gen), 1) | self.assertEqual(next(gen), 1) | ||||
| self.assertEqual(next(gen), 2) | self.assertEqual(next(gen), 2) | ||||
| self.assertEqual(list(f.revs(stop=1)), [0, 1]) | self.assertEqual(list(f.revs(stop=1)), [0, 1]) | ||||
| self.assertEqual(list(f.revs(stop=2)), [0, 1, 2]) | self.assertEqual(list(f.revs(stop=2)), [0, 1, 2]) | ||||
| self.assertEqual(list(f.revs(stop=3)), [0, 1, 2]) | self.assertEqual(list(f.revs(stop=3)), [0, 1, 2]) | ||||
| self.assertEqual(list(f.revs(2, 0)), [2, 1, 0]) | self.assertEqual(list(f.revs(2, 0)), [2, 1, 0]) | ||||
| self.assertEqual(list(f.revs(2, 1)), [2, 1]) | self.assertEqual(list(f.revs(2, 1)), [2, 1]) | ||||
| # TODO this is wrong | # TODO this is wrong | ||||
| self.assertEqual(list(f.revs(3, 2)), [3, 2]) | self.assertEqual(list(f.revs(3, 2)), [3, 2]) | ||||
| self.assertEqual(f.parents(node0), (nullid, nullid)) | self.assertEqual(f.parents(node0), (f.nullid, f.nullid)) | ||||
| self.assertEqual(f.parents(node1), (node0, nullid)) | self.assertEqual(f.parents(node1), (node0, f.nullid)) | ||||
| self.assertEqual(f.parents(node2), (node1, nullid)) | self.assertEqual(f.parents(node2), (node1, f.nullid)) | ||||
| self.assertEqual(f.parentrevs(0), (nullrev, nullrev)) | self.assertEqual(f.parentrevs(0), (nullrev, nullrev)) | ||||
| self.assertEqual(f.parentrevs(1), (0, nullrev)) | self.assertEqual(f.parentrevs(1), (0, nullrev)) | ||||
| self.assertEqual(f.parentrevs(2), (1, nullrev)) | self.assertEqual(f.parentrevs(2), (1, nullrev)) | ||||
| self.assertEqual(f.rev(node0), 0) | self.assertEqual(f.rev(node0), 0) | ||||
| self.assertEqual(f.rev(node1), 1) | self.assertEqual(f.rev(node1), 1) | ||||
| self.assertEqual(f.rev(node2), 2) | self.assertEqual(f.rev(node2), 2) | ||||
| self.assertFalse(f.iscensored(0)) | self.assertFalse(f.iscensored(0)) | ||||
| self.assertFalse(f.iscensored(1)) | self.assertFalse(f.iscensored(1)) | ||||
| self.assertFalse(f.iscensored(2)) | self.assertFalse(f.iscensored(2)) | ||||
| with self.assertRaises(IndexError): | with self.assertRaises(IndexError): | ||||
| f.iscensored(3) | f.iscensored(3) | ||||
| self.assertEqual(f.commonancestorsheads(node1, nullid), []) | self.assertEqual(f.commonancestorsheads(node1, f.nullid), []) | ||||
| self.assertEqual(f.commonancestorsheads(node1, node0), [node0]) | self.assertEqual(f.commonancestorsheads(node1, node0), [node0]) | ||||
| self.assertEqual(f.commonancestorsheads(node1, node1), [node1]) | self.assertEqual(f.commonancestorsheads(node1, node1), [node1]) | ||||
| self.assertEqual(f.commonancestorsheads(node0, node1), [node0]) | self.assertEqual(f.commonancestorsheads(node0, node1), [node0]) | ||||
| self.assertEqual(f.commonancestorsheads(node1, node2), [node1]) | self.assertEqual(f.commonancestorsheads(node1, node2), [node1]) | ||||
| self.assertEqual(f.commonancestorsheads(node2, node1), [node1]) | self.assertEqual(f.commonancestorsheads(node2, node1), [node1]) | ||||
| self.assertEqual(list(f.descendants([0])), [1, 2]) | self.assertEqual(list(f.descendants([0])), [1, 2]) | ||||
| self.assertEqual(list(f.descendants([1])), [2]) | self.assertEqual(list(f.descendants([1])), [2]) | ||||
| self.assertEqual(f.children(node0), [node1]) | self.assertEqual(f.children(node0), [node1]) | ||||
| self.assertEqual(f.children(node1), [node2]) | self.assertEqual(f.children(node1), [node2]) | ||||
| self.assertEqual(f.children(node2), []) | self.assertEqual(f.children(node2), []) | ||||
| def testmultipleheads(self): | def testmultipleheads(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(b'0', None, tr, 0, nullid, nullid) | node0 = f.add(b'0', None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = f.add(b'1', None, tr, 1, node0, nullid) | node1 = f.add(b'1', None, tr, 1, node0, f.nullid) | ||||
| node2 = f.add(b'2', None, tr, 2, node1, nullid) | node2 = f.add(b'2', None, tr, 2, node1, f.nullid) | ||||
| node3 = f.add(b'3', None, tr, 3, node0, nullid) | node3 = f.add(b'3', None, tr, 3, node0, f.nullid) | ||||
| node4 = f.add(b'4', None, tr, 4, node3, nullid) | node4 = f.add(b'4', None, tr, 4, node3, f.nullid) | ||||
| node5 = f.add(b'5', None, tr, 5, node0, nullid) | node5 = f.add(b'5', None, tr, 5, node0, f.nullid) | ||||
| self.assertEqual(len(f), 6) | self.assertEqual(len(f), 6) | ||||
| self.assertEqual(list(f.descendants([0])), [1, 2, 3, 4, 5]) | self.assertEqual(list(f.descendants([0])), [1, 2, 3, 4, 5]) | ||||
| self.assertEqual(list(f.descendants([1])), [2]) | self.assertEqual(list(f.descendants([1])), [2]) | ||||
| self.assertEqual(list(f.descendants([2])), []) | self.assertEqual(list(f.descendants([2])), []) | ||||
| self.assertEqual(list(f.descendants([3])), [4]) | self.assertEqual(list(f.descendants([3])), [4]) | ||||
| self.assertEqual(list(f.descendants([0, 1])), [1, 2, 3, 4, 5]) | self.assertEqual(list(f.descendants([0, 1])), [1, 2, 3, 4, 5]) | ||||
| for i in range(-5, 5): | for i in range(-5, 5): | ||||
| if i == nullrev: | if i == nullrev: | ||||
| continue | continue | ||||
| with self.assertRaises(IndexError): | with self.assertRaises(IndexError): | ||||
| f.size(i) | f.size(i) | ||||
| self.assertEqual(f.revision(nullid), b'') | self.assertEqual(f.revision(f.nullid), b'') | ||||
| self.assertEqual(f.rawdata(nullid), b'') | self.assertEqual(f.rawdata(f.nullid), b'') | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.revision(b'\x01' * 20) | f.revision(b'\x01' * 20) | ||||
| self.assertEqual(f.read(nullid), b'') | self.assertEqual(f.read(f.nullid), b'') | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.read(b'\x01' * 20) | f.read(b'\x01' * 20) | ||||
| self.assertFalse(f.renamed(nullid)) | self.assertFalse(f.renamed(f.nullid)) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.read(b'\x01' * 20) | f.read(b'\x01' * 20) | ||||
| self.assertTrue(f.cmp(nullid, b'')) | self.assertTrue(f.cmp(f.nullid, b'')) | ||||
| self.assertTrue(f.cmp(nullid, b'foo')) | self.assertTrue(f.cmp(f.nullid, b'foo')) | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| f.cmp(b'\x01' * 20, b'irrelevant') | f.cmp(b'\x01' * 20, b'irrelevant') | ||||
| # Emitting empty list is an empty generator. | # Emitting empty list is an empty generator. | ||||
| gen = f.emitrevisions([]) | gen = f.emitrevisions([]) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| # Emitting null node yields nothing. | # Emitting null node yields nothing. | ||||
| gen = f.emitrevisions([nullid]) | gen = f.emitrevisions([f.nullid]) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| # Requesting unknown node fails. | # Requesting unknown node fails. | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| list(f.emitrevisions([b'\x01' * 20])) | list(f.emitrevisions([b'\x01' * 20])) | ||||
| def testsinglerevision(self): | def testsinglerevision(self): | ||||
| fulltext = b'initial' | fulltext = b'initial' | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node = f.add(fulltext, None, tr, 0, nullid, nullid) | node = f.add(fulltext, None, tr, 0, f.nullid, f.nullid) | ||||
| self.assertEqual(f.storageinfo(), {}) | self.assertEqual(f.storageinfo(), {}) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| f.storageinfo(revisionscount=True, trackedsize=True), | f.storageinfo(revisionscount=True, trackedsize=True), | ||||
| {b'revisionscount': 1, b'trackedsize': len(fulltext)}, | {b'revisionscount': 1, b'trackedsize': len(fulltext)}, | ||||
| ) | ) | ||||
| self.assertEqual(f.size(0), len(fulltext)) | self.assertEqual(f.size(0), len(fulltext)) | ||||
| self.assertFalse(f.cmp(node, fulltext)) | self.assertFalse(f.cmp(node, fulltext)) | ||||
| self.assertTrue(f.cmp(node, fulltext + b'extra')) | self.assertTrue(f.cmp(node, fulltext + b'extra')) | ||||
| # Emitting a single revision works. | # Emitting a single revision works. | ||||
| gen = f.emitrevisions([node]) | gen = f.emitrevisions([node]) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node) | self.assertEqual(rev.node, node) | ||||
| self.assertEqual(rev.p1node, nullid) | self.assertEqual(rev.p1node, f.nullid) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertIsNone(rev.linknode) | self.assertIsNone(rev.linknode) | ||||
| self.assertEqual(rev.basenode, nullid) | self.assertEqual(rev.basenode, f.nullid) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertIsNone(rev.revision) | self.assertIsNone(rev.revision) | ||||
| self.assertIsNone(rev.delta) | self.assertIsNone(rev.delta) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| # Requesting revision data works. | # Requesting revision data works. | ||||
| gen = f.emitrevisions([node], revisiondata=True) | gen = f.emitrevisions([node], revisiondata=True) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node) | self.assertEqual(rev.node, node) | ||||
| self.assertEqual(rev.p1node, nullid) | self.assertEqual(rev.p1node, f.nullid) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertIsNone(rev.linknode) | self.assertIsNone(rev.linknode) | ||||
| self.assertEqual(rev.basenode, nullid) | self.assertEqual(rev.basenode, f.nullid) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertEqual(rev.revision, fulltext) | self.assertEqual(rev.revision, fulltext) | ||||
| self.assertIsNone(rev.delta) | self.assertIsNone(rev.delta) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| # Emitting an unknown node after a known revision results in error. | # Emitting an unknown node after a known revision results in error. | ||||
| with self.assertRaises(error.LookupError): | with self.assertRaises(error.LookupError): | ||||
| list(f.emitrevisions([node, b'\x01' * 20])) | list(f.emitrevisions([node, b'\x01' * 20])) | ||||
| def testmultiplerevisions(self): | def testmultiplerevisions(self): | ||||
| fulltext0 = b'x' * 1024 | fulltext0 = b'x' * 1024 | ||||
| fulltext1 = fulltext0 + b'y' | fulltext1 = fulltext0 + b'y' | ||||
| fulltext2 = b'y' + fulltext0 + b'z' | fulltext2 = b'y' + fulltext0 + b'z' | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) | node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = f.add(fulltext1, None, tr, 1, node0, nullid) | node1 = f.add(fulltext1, None, tr, 1, node0, f.nullid) | ||||
| node2 = f.add(fulltext2, None, tr, 3, node1, nullid) | node2 = f.add(fulltext2, None, tr, 3, node1, f.nullid) | ||||
| self.assertEqual(f.storageinfo(), {}) | self.assertEqual(f.storageinfo(), {}) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| f.storageinfo(revisionscount=True, trackedsize=True), | f.storageinfo(revisionscount=True, trackedsize=True), | ||||
| { | { | ||||
| b'revisionscount': 3, | b'revisionscount': 3, | ||||
| b'trackedsize': len(fulltext0) | b'trackedsize': len(fulltext0) | ||||
| + len(fulltext1) | + len(fulltext1) | ||||
| f.cmp(b'\x01' * 20, b'irrelevant') | f.cmp(b'\x01' * 20, b'irrelevant') | ||||
| # Nodes should be emitted in order. | # Nodes should be emitted in order. | ||||
| gen = f.emitrevisions([node0, node1, node2], revisiondata=True) | gen = f.emitrevisions([node0, node1, node2], revisiondata=True) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node0) | self.assertEqual(rev.node, node0) | ||||
| self.assertEqual(rev.p1node, nullid) | self.assertEqual(rev.p1node, f.nullid) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertIsNone(rev.linknode) | self.assertIsNone(rev.linknode) | ||||
| self.assertEqual(rev.basenode, nullid) | self.assertEqual(rev.basenode, f.nullid) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertEqual(rev.revision, fulltext0) | self.assertEqual(rev.revision, fulltext0) | ||||
| self.assertIsNone(rev.delta) | self.assertIsNone(rev.delta) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node1) | self.assertEqual(rev.node, node1) | ||||
| self.assertEqual(rev.p1node, node0) | self.assertEqual(rev.p1node, node0) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertIsNone(rev.linknode) | self.assertIsNone(rev.linknode) | ||||
| self.assertEqual(rev.basenode, node0) | self.assertEqual(rev.basenode, node0) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertIsNone(rev.revision) | self.assertIsNone(rev.revision) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| rev.delta, | rev.delta, | ||||
| b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1, | b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1, | ||||
| ) | ) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node2) | self.assertEqual(rev.node, node2) | ||||
| self.assertEqual(rev.p1node, node1) | self.assertEqual(rev.p1node, node1) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertIsNone(rev.linknode) | self.assertIsNone(rev.linknode) | ||||
| self.assertEqual(rev.basenode, node1) | self.assertEqual(rev.basenode, node1) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertIsNone(rev.revision) | self.assertIsNone(rev.revision) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| rev.delta, | rev.delta, | ||||
| b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2, | b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2, | ||||
| ) | ) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| # Request not in DAG order is reordered to be in DAG order. | # Request not in DAG order is reordered to be in DAG order. | ||||
| gen = f.emitrevisions([node2, node1, node0], revisiondata=True) | gen = f.emitrevisions([node2, node1, node0], revisiondata=True) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node0) | self.assertEqual(rev.node, node0) | ||||
| self.assertEqual(rev.p1node, nullid) | self.assertEqual(rev.p1node, f.nullid) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertIsNone(rev.linknode) | self.assertIsNone(rev.linknode) | ||||
| self.assertEqual(rev.basenode, nullid) | self.assertEqual(rev.basenode, f.nullid) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertEqual(rev.revision, fulltext0) | self.assertEqual(rev.revision, fulltext0) | ||||
| self.assertIsNone(rev.delta) | self.assertIsNone(rev.delta) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node1) | self.assertEqual(rev.node, node1) | ||||
| self.assertEqual(rev.p1node, node0) | self.assertEqual(rev.p1node, node0) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertIsNone(rev.linknode) | self.assertIsNone(rev.linknode) | ||||
| self.assertEqual(rev.basenode, node0) | self.assertEqual(rev.basenode, node0) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertIsNone(rev.revision) | self.assertIsNone(rev.revision) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| rev.delta, | rev.delta, | ||||
| b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1, | b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1, | ||||
| ) | ) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node2) | self.assertEqual(rev.node, node2) | ||||
| self.assertEqual(rev.p1node, node1) | self.assertEqual(rev.p1node, node1) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertIsNone(rev.linknode) | self.assertIsNone(rev.linknode) | ||||
| self.assertEqual(rev.basenode, node1) | self.assertEqual(rev.basenode, node1) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertIsNone(rev.revision) | self.assertIsNone(rev.revision) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| rev.delta, | rev.delta, | ||||
| b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2, | b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2, | ||||
| ) | ) | ||||
| # nodesorder=nodes forces the order. | # nodesorder=nodes forces the order. | ||||
| gen = f.emitrevisions( | gen = f.emitrevisions( | ||||
| [node2, node0], nodesorder=b'nodes', revisiondata=True | [node2, node0], nodesorder=b'nodes', revisiondata=True | ||||
| ) | ) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node2) | self.assertEqual(rev.node, node2) | ||||
| self.assertEqual(rev.p1node, node1) | self.assertEqual(rev.p1node, node1) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertEqual(rev.basenode, nullid) | self.assertEqual(rev.basenode, f.nullid) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertEqual(rev.revision, fulltext2) | self.assertEqual(rev.revision, fulltext2) | ||||
| self.assertIsNone(rev.delta) | self.assertIsNone(rev.delta) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node0) | self.assertEqual(rev.node, node0) | ||||
| self.assertEqual(rev.p1node, nullid) | self.assertEqual(rev.p1node, f.nullid) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| # Delta behavior is storage dependent, so we can't easily test it. | # Delta behavior is storage dependent, so we can't easily test it. | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| # assumehaveparentrevisions=False (the default) won't send a delta for | # assumehaveparentrevisions=False (the default) won't send a delta for | ||||
| # the first revision. | # the first revision. | ||||
| gen = f.emitrevisions({node2, node1}, revisiondata=True) | gen = f.emitrevisions({node2, node1}, revisiondata=True) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node1) | self.assertEqual(rev.node, node1) | ||||
| self.assertEqual(rev.p1node, node0) | self.assertEqual(rev.p1node, node0) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertEqual(rev.basenode, nullid) | self.assertEqual(rev.basenode, f.nullid) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertEqual(rev.revision, fulltext1) | self.assertEqual(rev.revision, fulltext1) | ||||
| self.assertIsNone(rev.delta) | self.assertIsNone(rev.delta) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node2) | self.assertEqual(rev.node, node2) | ||||
| self.assertEqual(rev.p1node, node1) | self.assertEqual(rev.p1node, node1) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertEqual(rev.basenode, node1) | self.assertEqual(rev.basenode, node1) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertIsNone(rev.revision) | self.assertIsNone(rev.revision) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| rev.delta, | rev.delta, | ||||
| b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2, | b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x04\x02' + fulltext2, | ||||
| ) | ) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| # assumehaveparentrevisions=True allows delta against initial revision. | # assumehaveparentrevisions=True allows delta against initial revision. | ||||
| gen = f.emitrevisions( | gen = f.emitrevisions( | ||||
| [node2, node1], revisiondata=True, assumehaveparentrevisions=True | [node2, node1], revisiondata=True, assumehaveparentrevisions=True | ||||
| ) | ) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node1) | self.assertEqual(rev.node, node1) | ||||
| self.assertEqual(rev.p1node, node0) | self.assertEqual(rev.p1node, node0) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertEqual(rev.basenode, node0) | self.assertEqual(rev.basenode, node0) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertIsNone(rev.revision) | self.assertIsNone(rev.revision) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| rev.delta, | rev.delta, | ||||
| b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1, | b'\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x01' + fulltext1, | ||||
| ) | ) | ||||
| # forceprevious=True forces a delta against the previous revision. | # forceprevious=True forces a delta against the previous revision. | ||||
| # Special case for initial revision. | # Special case for initial revision. | ||||
| gen = f.emitrevisions( | gen = f.emitrevisions( | ||||
| [node0], revisiondata=True, deltamode=repository.CG_DELTAMODE_PREV | [node0], revisiondata=True, deltamode=repository.CG_DELTAMODE_PREV | ||||
| ) | ) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node0) | self.assertEqual(rev.node, node0) | ||||
| self.assertEqual(rev.p1node, nullid) | self.assertEqual(rev.p1node, f.nullid) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertEqual(rev.basenode, nullid) | self.assertEqual(rev.basenode, f.nullid) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertIsNone(rev.revision) | self.assertIsNone(rev.revision) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| rev.delta, | rev.delta, | ||||
| b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0, | b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0, | ||||
| ) | ) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| gen = f.emitrevisions( | gen = f.emitrevisions( | ||||
| [node0, node2], | [node0, node2], | ||||
| revisiondata=True, | revisiondata=True, | ||||
| deltamode=repository.CG_DELTAMODE_PREV, | deltamode=repository.CG_DELTAMODE_PREV, | ||||
| ) | ) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node0) | self.assertEqual(rev.node, node0) | ||||
| self.assertEqual(rev.p1node, nullid) | self.assertEqual(rev.p1node, f.nullid) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertEqual(rev.basenode, nullid) | self.assertEqual(rev.basenode, f.nullid) | ||||
| self.assertIsNone(rev.baserevisionsize) | self.assertIsNone(rev.baserevisionsize) | ||||
| self.assertIsNone(rev.revision) | self.assertIsNone(rev.revision) | ||||
| self.assertEqual( | self.assertEqual( | ||||
| rev.delta, | rev.delta, | ||||
| b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0, | b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' + fulltext0, | ||||
| ) | ) | ||||
| rev = next(gen) | rev = next(gen) | ||||
| self.assertEqual(rev.node, node2) | self.assertEqual(rev.node, node2) | ||||
| self.assertEqual(rev.p1node, node1) | self.assertEqual(rev.p1node, node1) | ||||
| self.assertEqual(rev.p2node, nullid) | self.assertEqual(rev.p2node, f.nullid) | ||||
| self.assertEqual(rev.basenode, node0) | self.assertEqual(rev.basenode, node0) | ||||
| with self.assertRaises(StopIteration): | with self.assertRaises(StopIteration): | ||||
| next(gen) | next(gen) | ||||
| def testrenamed(self): | def testrenamed(self): | ||||
| fulltext0 = b'foo' | fulltext0 = b'foo' | ||||
| fulltext1 = b'bar' | fulltext1 = b'bar' | ||||
| b'\x01\ncopy: source1\n', | b'\x01\ncopy: source1\n', | ||||
| b'copyrev: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n\x01\n', | b'copyrev: bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n\x01\n', | ||||
| fulltext2, | fulltext2, | ||||
| ] | ] | ||||
| ) | ) | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) | node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = f.add(fulltext1, meta1, tr, 1, node0, nullid) | node1 = f.add(fulltext1, meta1, tr, 1, node0, f.nullid) | ||||
| node2 = f.add(fulltext2, meta2, tr, 2, nullid, nullid) | node2 = f.add(fulltext2, meta2, tr, 2, f.nullid, f.nullid) | ||||
| # Metadata header isn't recognized when parent isn't nullid. | # Metadata header isn't recognized when parent isn't f.nullid. | ||||
| self.assertEqual(f.size(1), len(stored1)) | self.assertEqual(f.size(1), len(stored1)) | ||||
| self.assertEqual(f.size(2), len(fulltext2)) | self.assertEqual(f.size(2), len(fulltext2)) | ||||
| self.assertEqual(f.revision(node1), stored1) | self.assertEqual(f.revision(node1), stored1) | ||||
| self.assertEqual(f.rawdata(node1), stored1) | self.assertEqual(f.rawdata(node1), stored1) | ||||
| self.assertEqual(f.revision(node2), stored2) | self.assertEqual(f.revision(node2), stored2) | ||||
| self.assertEqual(f.rawdata(node2), stored2) | self.assertEqual(f.rawdata(node2), stored2) | ||||
| b'\x01\ncopy: source0\n', | b'\x01\ncopy: source0\n', | ||||
| b'copyrev: %s\n' % (b'b' * 40), | b'copyrev: %s\n' % (b'b' * 40), | ||||
| b'\x01\n\x01\nbar', | b'\x01\n\x01\nbar', | ||||
| ] | ] | ||||
| ) | ) | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(fulltext0, {}, tr, 0, nullid, nullid) | node0 = f.add(fulltext0, {}, tr, 0, f.nullid, f.nullid) | ||||
| node1 = f.add(fulltext1, meta1, tr, 1, nullid, nullid) | node1 = f.add(fulltext1, meta1, tr, 1, f.nullid, f.nullid) | ||||
| # TODO this is buggy. | # TODO this is buggy. | ||||
| self.assertEqual(f.size(0), len(fulltext0) + 4) | self.assertEqual(f.size(0), len(fulltext0) + 4) | ||||
| self.assertEqual(f.size(1), len(fulltext1)) | self.assertEqual(f.size(1), len(fulltext1)) | ||||
| self.assertEqual(f.revision(node0), stored0) | self.assertEqual(f.revision(node0), stored0) | ||||
| self.assertEqual(f.rawdata(node0), stored0) | self.assertEqual(f.rawdata(node0), stored0) | ||||
| def testbadnoderead(self): | def testbadnoderead(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| fulltext0 = b'foo\n' * 30 | fulltext0 = b'foo\n' * 30 | ||||
| fulltext1 = fulltext0 + b'bar\n' | fulltext1 = fulltext0 + b'bar\n' | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) | node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = b'\xaa' * 20 | node1 = b'\xaa' * 20 | ||||
| self._addrawrevisionfn( | self._addrawrevisionfn( | ||||
| f, tr, node1, node0, nullid, 1, rawtext=fulltext1 | f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1 | ||||
| ) | ) | ||||
| self.assertEqual(len(f), 2) | self.assertEqual(len(f), 2) | ||||
| self.assertEqual(f.parents(node1), (node0, nullid)) | self.assertEqual(f.parents(node1), (node0, f.nullid)) | ||||
| # revision() raises since it performs hash verification. | # revision() raises since it performs hash verification. | ||||
| with self.assertRaises(error.StorageError): | with self.assertRaises(error.StorageError): | ||||
| f.revision(node1) | f.revision(node1) | ||||
| # rawdata() still verifies because there are no special storage | # rawdata() still verifies because there are no special storage | ||||
| # settings. | # settings. | ||||
| with self.assertRaises(error.StorageError): | with self.assertRaises(error.StorageError): | ||||
| # Like above except we test rawdata() first to isolate | # Like above except we test rawdata() first to isolate | ||||
| # revision caching behavior. | # revision caching behavior. | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| fulltext0 = b'foo\n' * 30 | fulltext0 = b'foo\n' * 30 | ||||
| fulltext1 = fulltext0 + b'bar\n' | fulltext1 = fulltext0 + b'bar\n' | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) | node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = b'\xaa' * 20 | node1 = b'\xaa' * 20 | ||||
| self._addrawrevisionfn( | self._addrawrevisionfn( | ||||
| f, tr, node1, node0, nullid, 1, rawtext=fulltext1 | f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1 | ||||
| ) | ) | ||||
| with self.assertRaises(error.StorageError): | with self.assertRaises(error.StorageError): | ||||
| f.rawdata(node1) | f.rawdata(node1) | ||||
| with self.assertRaises(error.StorageError): | with self.assertRaises(error.StorageError): | ||||
| f.rawdata(node1) | f.rawdata(node1) | ||||
| def testbadnoderevision(self): | def testbadnoderevision(self): | ||||
| # Like above except we test read() first to isolate revision caching | # Like above except we test read() first to isolate revision caching | ||||
| # behavior. | # behavior. | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| fulltext0 = b'foo\n' * 30 | fulltext0 = b'foo\n' * 30 | ||||
| fulltext1 = fulltext0 + b'bar\n' | fulltext1 = fulltext0 + b'bar\n' | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) | node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = b'\xaa' * 20 | node1 = b'\xaa' * 20 | ||||
| self._addrawrevisionfn( | self._addrawrevisionfn( | ||||
| f, tr, node1, node0, nullid, 1, rawtext=fulltext1 | f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1 | ||||
| ) | ) | ||||
| with self.assertRaises(error.StorageError): | with self.assertRaises(error.StorageError): | ||||
| f.read(node1) | f.read(node1) | ||||
| with self.assertRaises(error.StorageError): | with self.assertRaises(error.StorageError): | ||||
| f.read(node1) | f.read(node1) | ||||
| def testbadnodedelta(self): | def testbadnodedelta(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| fulltext0 = b'foo\n' * 31 | fulltext0 = b'foo\n' * 31 | ||||
| fulltext1 = fulltext0 + b'bar\n' | fulltext1 = fulltext0 + b'bar\n' | ||||
| fulltext2 = fulltext1 + b'baz\n' | fulltext2 = fulltext1 + b'baz\n' | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) | node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = b'\xaa' * 20 | node1 = b'\xaa' * 20 | ||||
| self._addrawrevisionfn( | self._addrawrevisionfn( | ||||
| f, tr, node1, node0, nullid, 1, rawtext=fulltext1 | f, tr, node1, node0, f.nullid, 1, rawtext=fulltext1 | ||||
| ) | ) | ||||
| with self.assertRaises(error.StorageError): | with self.assertRaises(error.StorageError): | ||||
| f.read(node1) | f.read(node1) | ||||
| node2 = storageutil.hashrevisionsha1(fulltext2, node1, nullid) | node2 = storageutil.hashrevisionsha1(fulltext2, node1, f.nullid) | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| delta = mdiff.textdiff(fulltext1, fulltext2) | delta = mdiff.textdiff(fulltext1, fulltext2) | ||||
| self._addrawrevisionfn( | self._addrawrevisionfn( | ||||
| f, tr, node2, node1, nullid, 2, delta=(1, delta) | f, tr, node2, node1, f.nullid, 2, delta=(1, delta) | ||||
| ) | ) | ||||
| self.assertEqual(len(f), 3) | self.assertEqual(len(f), 3) | ||||
| # Assuming a delta is stored, we shouldn't need to validate node1 in | # Assuming a delta is stored, we shouldn't need to validate node1 in | ||||
| # order to retrieve node2. | # order to retrieve node2. | ||||
| self.assertEqual(f.read(node2), fulltext2) | self.assertEqual(f.read(node2), fulltext2) | ||||
| def testcensored(self): | def testcensored(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| stored1 = storageutil.packmeta( | stored1 = storageutil.packmeta( | ||||
| { | { | ||||
| b'censored': b'tombstone', | b'censored': b'tombstone', | ||||
| }, | }, | ||||
| b'', | b'', | ||||
| ) | ) | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(b'foo', None, tr, 0, nullid, nullid) | node0 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid) | ||||
| # The node value doesn't matter since we can't verify it. | # The node value doesn't matter since we can't verify it. | ||||
| node1 = b'\xbb' * 20 | node1 = b'\xbb' * 20 | ||||
| self._addrawrevisionfn( | self._addrawrevisionfn( | ||||
| f, tr, node1, node0, nullid, 1, stored1, censored=True | f, tr, node1, node0, f.nullid, 1, stored1, censored=True | ||||
| ) | ) | ||||
| self.assertTrue(f.iscensored(1)) | self.assertTrue(f.iscensored(1)) | ||||
| with self.assertRaises(error.CensoredNodeError): | with self.assertRaises(error.CensoredNodeError): | ||||
| f.revision(1) | f.revision(1) | ||||
| with self.assertRaises(error.CensoredNodeError): | with self.assertRaises(error.CensoredNodeError): | ||||
| stored1 = storageutil.packmeta( | stored1 = storageutil.packmeta( | ||||
| { | { | ||||
| b'censored': b'tombstone', | b'censored': b'tombstone', | ||||
| }, | }, | ||||
| b'', | b'', | ||||
| ) | ) | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(b'foo', None, tr, 0, nullid, nullid) | node0 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid) | ||||
| # The node value doesn't matter since we can't verify it. | # The node value doesn't matter since we can't verify it. | ||||
| node1 = b'\xbb' * 20 | node1 = b'\xbb' * 20 | ||||
| self._addrawrevisionfn( | self._addrawrevisionfn( | ||||
| f, tr, node1, node0, nullid, 1, stored1, censored=True | f, tr, node1, node0, f.nullid, 1, stored1, censored=True | ||||
| ) | ) | ||||
| with self.assertRaises(error.CensoredNodeError): | with self.assertRaises(error.CensoredNodeError): | ||||
| f.rawdata(1) | f.rawdata(1) | ||||
| class ifilemutationtests(basetestcase): | class ifilemutationtests(basetestcase): | ||||
| """Generic tests for the ifilemutation interface. | """Generic tests for the ifilemutation interface. | ||||
| All file storage backends that support writing should conform to this | All file storage backends that support writing should conform to this | ||||
| interface. | interface. | ||||
| Use ``makeifilemutationtests()`` to create an instance of this type. | Use ``makeifilemutationtests()`` to create an instance of this type. | ||||
| """ | """ | ||||
| def testaddnoop(self): | def testaddnoop(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(b'foo', None, tr, 0, nullid, nullid) | node0 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = f.add(b'foo', None, tr, 0, nullid, nullid) | node1 = f.add(b'foo', None, tr, 0, f.nullid, f.nullid) | ||||
| # Varying by linkrev shouldn't impact hash. | # Varying by linkrev shouldn't impact hash. | ||||
| node2 = f.add(b'foo', None, tr, 1, nullid, nullid) | node2 = f.add(b'foo', None, tr, 1, f.nullid, f.nullid) | ||||
| self.assertEqual(node1, node0) | self.assertEqual(node1, node0) | ||||
| self.assertEqual(node2, node0) | self.assertEqual(node2, node0) | ||||
| self.assertEqual(len(f), 1) | self.assertEqual(len(f), 1) | ||||
| def testaddrevisionbadnode(self): | def testaddrevisionbadnode(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| # Adding a revision with bad node value fails. | # Adding a revision with bad node value fails. | ||||
| with self.assertRaises(error.StorageError): | with self.assertRaises(error.StorageError): | ||||
| f.addrevision(b'foo', tr, 0, nullid, nullid, node=b'\x01' * 20) | f.addrevision( | ||||
| b'foo', tr, 0, f.nullid, f.nullid, node=b'\x01' * 20 | |||||
| ) | |||||
| def testaddrevisionunknownflag(self): | def testaddrevisionunknownflag(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| for i in range(15, 0, -1): | for i in range(15, 0, -1): | ||||
| if (1 << i) & ~repository.REVISION_FLAGS_KNOWN: | if (1 << i) & ~repository.REVISION_FLAGS_KNOWN: | ||||
| flags = 1 << i | flags = 1 << i | ||||
| break | break | ||||
| with self.assertRaises(error.StorageError): | with self.assertRaises(error.StorageError): | ||||
| f.addrevision(b'foo', tr, 0, nullid, nullid, flags=flags) | f.addrevision(b'foo', tr, 0, f.nullid, f.nullid, flags=flags) | ||||
| def testaddgroupsimple(self): | def testaddgroupsimple(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| callbackargs = [] | callbackargs = [] | ||||
| def cb(*args, **kwargs): | def cb(*args, **kwargs): | ||||
| callbackargs.append((args, kwargs)) | callbackargs.append((args, kwargs)) | ||||
| self.assertEqual(nodes, []) | self.assertEqual(nodes, []) | ||||
| self.assertEqual(callbackargs, []) | self.assertEqual(callbackargs, []) | ||||
| self.assertEqual(len(f), 0) | self.assertEqual(len(f), 0) | ||||
| fulltext0 = b'foo' | fulltext0 = b'foo' | ||||
| delta0 = mdiff.trivialdiffheader(len(fulltext0)) + fulltext0 | delta0 = mdiff.trivialdiffheader(len(fulltext0)) + fulltext0 | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(fulltext0, None, tr, 0, nullid, nullid) | node0 = f.add(fulltext0, None, tr, 0, f.nullid, f.nullid) | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| deltas = [ | deltas = [ | ||||
| (node0, nullid, nullid, nullid, nullid, delta0, 0, {}), | (node0, f.nullid, f.nullid, f.nullid, f.nullid, delta0, 0, {}), | ||||
| ] | ] | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| nodes = [] | nodes = [] | ||||
| def onchangeset(cl, rev): | def onchangeset(cl, rev): | ||||
| node = cl.node(rev) | node = cl.node(rev) | ||||
| nodes.append(node) | nodes.append(node) | ||||
| b'foo', | b'foo', | ||||
| b'bar', | b'bar', | ||||
| b'x' * 1024, | b'x' * 1024, | ||||
| ] | ] | ||||
| nodes = [] | nodes = [] | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| for fulltext in fulltexts: | for fulltext in fulltexts: | ||||
| nodes.append(f.add(fulltext, None, tr, 0, nullid, nullid)) | nodes.append(f.add(fulltext, None, tr, 0, f.nullid, f.nullid)) | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| deltas = [] | deltas = [] | ||||
| for i, fulltext in enumerate(fulltexts): | for i, fulltext in enumerate(fulltexts): | ||||
| delta = mdiff.trivialdiffheader(len(fulltext)) + fulltext | delta = mdiff.trivialdiffheader(len(fulltext)) + fulltext | ||||
| deltas.append( | deltas.append( | ||||
| (nodes[i], nullid, nullid, nullid, nullid, delta, 0, {}) | (nodes[i], f.nullid, f.nullid, f.nullid, f.nullid, delta, 0, {}) | ||||
| ) | ) | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| newnodes = [] | newnodes = [] | ||||
| def onchangeset(cl, rev): | def onchangeset(cl, rev): | ||||
| newnodes.append(cl.node(rev)) | newnodes.append(cl.node(rev)) | ||||
| stored1 = storageutil.packmeta( | stored1 = storageutil.packmeta( | ||||
| { | { | ||||
| b'censored': b'tombstone', | b'censored': b'tombstone', | ||||
| }, | }, | ||||
| b'', | b'', | ||||
| ) | ) | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(b'foo\n' * 30, None, tr, 0, nullid, nullid) | node0 = f.add(b'foo\n' * 30, None, tr, 0, f.nullid, f.nullid) | ||||
| # The node value doesn't matter since we can't verify it. | # The node value doesn't matter since we can't verify it. | ||||
| node1 = b'\xbb' * 20 | node1 = b'\xbb' * 20 | ||||
| self._addrawrevisionfn( | self._addrawrevisionfn( | ||||
| f, tr, node1, node0, nullid, 1, stored1, censored=True | f, tr, node1, node0, f.nullid, 1, stored1, censored=True | ||||
| ) | ) | ||||
| delta = mdiff.textdiff(b'bar\n' * 30, (b'bar\n' * 30) + b'baz\n') | delta = mdiff.textdiff(b'bar\n' * 30, (b'bar\n' * 30) + b'baz\n') | ||||
| deltas = [ | deltas = [ | ||||
| (b'\xcc' * 20, node1, nullid, b'\x01' * 20, node1, delta, 0, {}) | (b'\xcc' * 20, node1, f.nullid, b'\x01' * 20, node1, delta, 0, {}) | ||||
| ] | ] | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| with self.assertRaises(error.CensoredBaseError): | with self.assertRaises(error.CensoredBaseError): | ||||
| f.addgroup(deltas, lambda x: 0, tr) | f.addgroup(deltas, lambda x: 0, tr) | ||||
| def testcensorrevisionbasic(self): | def testcensorrevisionbasic(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(b'foo\n' * 30, None, tr, 0, nullid, nullid) | node0 = f.add(b'foo\n' * 30, None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = f.add(b'foo\n' * 31, None, tr, 1, node0, nullid) | node1 = f.add(b'foo\n' * 31, None, tr, 1, node0, f.nullid) | ||||
| node2 = f.add(b'foo\n' * 32, None, tr, 2, node1, nullid) | node2 = f.add(b'foo\n' * 32, None, tr, 2, node1, f.nullid) | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| f.censorrevision(tr, node1) | f.censorrevision(tr, node1) | ||||
| self.assertEqual(len(f), 3) | self.assertEqual(len(f), 3) | ||||
| self.assertEqual(list(f.revs()), [0, 1, 2]) | self.assertEqual(list(f.revs()), [0, 1, 2]) | ||||
| self.assertEqual(f.read(node0), b'foo\n' * 30) | self.assertEqual(f.read(node0), b'foo\n' * 30) | ||||
| self.assertEqual(f.read(node2), b'foo\n' * 32) | self.assertEqual(f.read(node2), b'foo\n' * 32) | ||||
| with self.assertRaises(error.CensoredNodeError): | with self.assertRaises(error.CensoredNodeError): | ||||
| f.read(node1) | f.read(node1) | ||||
| def testgetstrippointnoparents(self): | def testgetstrippointnoparents(self): | ||||
| # N revisions where none have parents. | # N revisions where none have parents. | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| for rev in range(10): | for rev in range(10): | ||||
| f.add(b'%d' % rev, None, tr, rev, nullid, nullid) | f.add(b'%d' % rev, None, tr, rev, f.nullid, f.nullid) | ||||
| for rev in range(10): | for rev in range(10): | ||||
| self.assertEqual(f.getstrippoint(rev), (rev, set())) | self.assertEqual(f.getstrippoint(rev), (rev, set())) | ||||
| def testgetstrippointlinear(self): | def testgetstrippointlinear(self): | ||||
| # N revisions in a linear chain. | # N revisions in a linear chain. | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| p1 = nullid | p1 = f.nullid | ||||
| for rev in range(10): | for rev in range(10): | ||||
| f.add(b'%d' % rev, None, tr, rev, p1, nullid) | f.add(b'%d' % rev, None, tr, rev, p1, f.nullid) | ||||
| for rev in range(10): | for rev in range(10): | ||||
| self.assertEqual(f.getstrippoint(rev), (rev, set())) | self.assertEqual(f.getstrippoint(rev), (rev, set())) | ||||
| def testgetstrippointmultipleheads(self): | def testgetstrippointmultipleheads(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(b'0', None, tr, 0, nullid, nullid) | node0 = f.add(b'0', None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = f.add(b'1', None, tr, 1, node0, nullid) | node1 = f.add(b'1', None, tr, 1, node0, f.nullid) | ||||
| f.add(b'2', None, tr, 2, node1, nullid) | f.add(b'2', None, tr, 2, node1, f.nullid) | ||||
| f.add(b'3', None, tr, 3, node0, nullid) | f.add(b'3', None, tr, 3, node0, f.nullid) | ||||
| f.add(b'4', None, tr, 4, node0, nullid) | f.add(b'4', None, tr, 4, node0, f.nullid) | ||||
| for rev in range(5): | for rev in range(5): | ||||
| self.assertEqual(f.getstrippoint(rev), (rev, set())) | self.assertEqual(f.getstrippoint(rev), (rev, set())) | ||||
| def testgetstrippointearlierlinkrevs(self): | def testgetstrippointearlierlinkrevs(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| node0 = f.add(b'0', None, tr, 0, nullid, nullid) | node0 = f.add(b'0', None, tr, 0, f.nullid, f.nullid) | ||||
| f.add(b'1', None, tr, 10, node0, nullid) | f.add(b'1', None, tr, 10, node0, f.nullid) | ||||
| f.add(b'2', None, tr, 5, node0, nullid) | f.add(b'2', None, tr, 5, node0, f.nullid) | ||||
| self.assertEqual(f.getstrippoint(0), (0, set())) | self.assertEqual(f.getstrippoint(0), (0, set())) | ||||
| self.assertEqual(f.getstrippoint(1), (1, set())) | self.assertEqual(f.getstrippoint(1), (1, set())) | ||||
| self.assertEqual(f.getstrippoint(2), (1, set())) | self.assertEqual(f.getstrippoint(2), (1, set())) | ||||
| self.assertEqual(f.getstrippoint(3), (1, set())) | self.assertEqual(f.getstrippoint(3), (1, set())) | ||||
| self.assertEqual(f.getstrippoint(4), (1, set())) | self.assertEqual(f.getstrippoint(4), (1, set())) | ||||
| self.assertEqual(f.getstrippoint(5), (1, set())) | self.assertEqual(f.getstrippoint(5), (1, set())) | ||||
| self.assertEqual(f.getstrippoint(6), (1, {2})) | self.assertEqual(f.getstrippoint(6), (1, {2})) | ||||
| f.strip(0, tr) | f.strip(0, tr) | ||||
| self.assertEqual(len(f), 0) | self.assertEqual(len(f), 0) | ||||
| def teststripall(self): | def teststripall(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| p1 = nullid | p1 = f.nullid | ||||
| for rev in range(10): | for rev in range(10): | ||||
| p1 = f.add(b'%d' % rev, None, tr, rev, p1, nullid) | p1 = f.add(b'%d' % rev, None, tr, rev, p1, f.nullid) | ||||
| self.assertEqual(len(f), 10) | self.assertEqual(len(f), 10) | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| f.strip(0, tr) | f.strip(0, tr) | ||||
| self.assertEqual(len(f), 0) | self.assertEqual(len(f), 0) | ||||
| def teststrippartial(self): | def teststrippartial(self): | ||||
| f = self._makefilefn() | f = self._makefilefn() | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| f.add(b'0', None, tr, 0, nullid, nullid) | f.add(b'0', None, tr, 0, f.nullid, f.nullid) | ||||
| node1 = f.add(b'1', None, tr, 5, nullid, nullid) | node1 = f.add(b'1', None, tr, 5, f.nullid, f.nullid) | ||||
| node2 = f.add(b'2', None, tr, 10, nullid, nullid) | node2 = f.add(b'2', None, tr, 10, f.nullid, f.nullid) | ||||
| self.assertEqual(len(f), 3) | self.assertEqual(len(f), 3) | ||||
| with self._maketransactionfn() as tr: | with self._maketransactionfn() as tr: | ||||
| f.strip(11, tr) | f.strip(11, tr) | ||||
| self.assertEqual(len(f), 3) | self.assertEqual(len(f), 3) | ||||
| # discovery.py - protocol changeset discovery functions | # discovery.py - protocol changeset discovery functions | ||||
| # | # | ||||
| # Copyright 2010 Olivia Mackall <olivia@selenic.com> | # Copyright 2010 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import short | ||||
| nullid, | |||||
| short, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| error, | error, | ||||
| pycompat, | pycompat, | ||||
| ) | ) | ||||
| def findcommonincoming(repo, remote, heads=None, force=False, audit=None): | def findcommonincoming(repo, remote, heads=None, force=False, audit=None): | ||||
| """Return a tuple (common, fetch, heads) used to identify the common | """Return a tuple (common, fetch, heads) used to identify the common | ||||
| if not heads: | if not heads: | ||||
| with remote.commandexecutor() as e: | with remote.commandexecutor() as e: | ||||
| heads = e.callcommand(b'heads', {}).result() | heads = e.callcommand(b'heads', {}).result() | ||||
| if audit is not None: | if audit is not None: | ||||
| audit[b'total-roundtrips'] = 1 | audit[b'total-roundtrips'] = 1 | ||||
| if repo.changelog.tip() == nullid: | if repo.changelog.tip() == repo.nullid: | ||||
| base.add(nullid) | base.add(repo.nullid) | ||||
| if heads != [nullid]: | if heads != [repo.nullid]: | ||||
| return [nullid], [nullid], list(heads) | return [repo.nullid], [repo.nullid], list(heads) | ||||
| return [nullid], [], heads | return [repo.nullid], [], heads | ||||
| # assume we're closer to the tip than the root | # assume we're closer to the tip than the root | ||||
| # and start by examining the heads | # and start by examining the heads | ||||
| repo.ui.status(_(b"searching for changes\n")) | repo.ui.status(_(b"searching for changes\n")) | ||||
| unknown = [] | unknown = [] | ||||
| for h in heads: | for h in heads: | ||||
| if not knownnode(h): | if not knownnode(h): | ||||
| while unknown: | while unknown: | ||||
| r = [] | r = [] | ||||
| while unknown: | while unknown: | ||||
| n = unknown.popleft() | n = unknown.popleft() | ||||
| if n[0] in seen: | if n[0] in seen: | ||||
| continue | continue | ||||
| repo.ui.debug(b"examining %s:%s\n" % (short(n[0]), short(n[1]))) | repo.ui.debug(b"examining %s:%s\n" % (short(n[0]), short(n[1]))) | ||||
| if n[0] == nullid: # found the end of the branch | if n[0] == repo.nullid: # found the end of the branch | ||||
| pass | pass | ||||
| elif n in seenbranch: | elif n in seenbranch: | ||||
| repo.ui.debug(b"branch already found\n") | repo.ui.debug(b"branch already found\n") | ||||
| continue | continue | ||||
| elif n[1] and knownnode(n[1]): # do we know the base? | elif n[1] and knownnode(n[1]): # do we know the base? | ||||
| repo.ui.debug( | repo.ui.debug( | ||||
| b"found incomplete branch %s:%s\n" | b"found incomplete branch %s:%s\n" | ||||
| % (short(n[0]), short(n[1])) | % (short(n[0]), short(n[1])) | ||||
| search = newsearch | search = newsearch | ||||
| # sanity check our fetch list | # sanity check our fetch list | ||||
| for f in fetch: | for f in fetch: | ||||
| if knownnode(f): | if knownnode(f): | ||||
| raise error.RepoError(_(b"already have changeset ") + short(f[:4])) | raise error.RepoError(_(b"already have changeset ") + short(f[:4])) | ||||
| base = list(base) | base = list(base) | ||||
| if base == [nullid]: | if base == [repo.nullid]: | ||||
| if force: | if force: | ||||
| repo.ui.warn(_(b"warning: repository is unrelated\n")) | repo.ui.warn(_(b"warning: repository is unrelated\n")) | ||||
| else: | else: | ||||
| raise error.Abort(_(b"repository is unrelated")) | raise error.Abort(_(b"repository is unrelated")) | ||||
| repo.ui.debug( | repo.ui.debug( | ||||
| b"found new changesets starting at " | b"found new changesets starting at " | ||||
| + b" ".join([short(f) for f in fetch]) | + b" ".join([short(f) for f in fetch]) | ||||
| import re as remod | import re as remod | ||||
| import shutil | import shutil | ||||
| import stat | import stat | ||||
| import sys | import sys | ||||
| import time | import time | ||||
| import traceback | import traceback | ||||
| import warnings | import warnings | ||||
| from .node import hex | |||||
| from .thirdparty import attr | from .thirdparty import attr | ||||
| from .pycompat import ( | from .pycompat import ( | ||||
| delattr, | delattr, | ||||
| getattr, | getattr, | ||||
| open, | open, | ||||
| setattr, | setattr, | ||||
| ) | ) | ||||
| from .node import hex | from .node import hex | ||||
| # storageutil.py - Storage functionality agnostic of backend implementation. | # storageutil.py - Storage functionality agnostic of backend implementation. | ||||
| # | # | ||||
| # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> | # Copyright 2018 Gregory Szorc <gregory.szorc@gmail.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import re | import re | ||||
| import struct | import struct | ||||
| from ..i18n import _ | from ..i18n import _ | ||||
| from ..node import ( | from ..node import ( | ||||
| bin, | bin, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| sha1nodeconstants, | |||||
| ) | ) | ||||
| from .. import ( | from .. import ( | ||||
| dagop, | dagop, | ||||
| error, | error, | ||||
| mdiff, | mdiff, | ||||
| pycompat, | pycompat, | ||||
| ) | ) | ||||
| from ..interfaces import repository | from ..interfaces import repository | ||||
| from ..revlogutils import sidedata as sidedatamod | from ..revlogutils import sidedata as sidedatamod | ||||
| from ..utils import hashutil | from ..utils import hashutil | ||||
| _nullhash = hashutil.sha1(nullid) | _nullhash = hashutil.sha1(sha1nodeconstants.nullid) | ||||
| def hashrevisionsha1(text, p1, p2): | def hashrevisionsha1(text, p1, p2): | ||||
| """Compute the SHA-1 for revision data and its parents. | """Compute the SHA-1 for revision data and its parents. | ||||
| This hash combines both the current file contents and its history | This hash combines both the current file contents and its history | ||||
| in a manner that makes it easy to distinguish nodes with the same | in a manner that makes it easy to distinguish nodes with the same | ||||
| content in the revision graph. | content in the revision graph. | ||||
| """ | """ | ||||
| # As of now, if one of the parent node is null, p2 is null | # As of now, if one of the parent node is null, p2 is null | ||||
| if p2 == nullid: | if p2 == sha1nodeconstants.nullid: | ||||
| # deep copy of a hash is faster than creating one | # deep copy of a hash is faster than creating one | ||||
| s = _nullhash.copy() | s = _nullhash.copy() | ||||
| s.update(p1) | s.update(p1) | ||||
| else: | else: | ||||
| # none of the parent nodes are nullid | # none of the parent nodes are nullid | ||||
| if p1 < p2: | if p1 < p2: | ||||
| a = p1 | a = p1 | ||||
| b = p2 | b = p2 | ||||
| def filerevisioncopied(store, node): | def filerevisioncopied(store, node): | ||||
| """Resolve file revision copy metadata. | """Resolve file revision copy metadata. | ||||
| Returns ``False`` if the file has no copy metadata. Otherwise a | Returns ``False`` if the file has no copy metadata. Otherwise a | ||||
| 2-tuple of the source filename and node. | 2-tuple of the source filename and node. | ||||
| """ | """ | ||||
| if store.parents(node)[0] != nullid: | if store.parents(node)[0] != sha1nodeconstants.nullid: | ||||
| return False | return False | ||||
| meta = parsemeta(store.revision(node))[0] | meta = parsemeta(store.revision(node))[0] | ||||
| # copy and copyrev occur in pairs. In rare cases due to old bugs, | # copy and copyrev occur in pairs. In rare cases due to old bugs, | ||||
| # one can occur without the other. So ensure both are present to flag | # one can occur without the other. So ensure both are present to flag | ||||
| # as a copy. | # as a copy. | ||||
| if meta and b'copy' in meta and b'copyrev' in meta: | if meta and b'copy' in meta and b'copyrev' in meta: | ||||
| # verify.py - repository integrity checking for Mercurial | # verify.py - repository integrity checking for Mercurial | ||||
| # | # | ||||
| # Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2006, 2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import os | import os | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import short | ||||
| nullid, | from .utils import stringutil | ||||
| short, | |||||
| ) | |||||
| from .utils import ( | |||||
| stringutil, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| error, | error, | ||||
| pycompat, | pycompat, | ||||
| revlog, | revlog, | ||||
| util, | util, | ||||
| ) | ) | ||||
| self._warn( | self._warn( | ||||
| _(b" (expected %s)") | _(b" (expected %s)") | ||||
| % b" ".join(map(pycompat.bytestr, linkrevs)) | % b" ".join(map(pycompat.bytestr, linkrevs)) | ||||
| ) | ) | ||||
| lr = None # can't be trusted | lr = None # can't be trusted | ||||
| try: | try: | ||||
| p1, p2 = obj.parents(node) | p1, p2 = obj.parents(node) | ||||
| if p1 not in seen and p1 != nullid: | if p1 not in seen and p1 != self.repo.nullid: | ||||
| self._err( | self._err( | ||||
| lr, | lr, | ||||
| _(b"unknown parent 1 %s of %s") % (short(p1), short(node)), | _(b"unknown parent 1 %s of %s") % (short(p1), short(node)), | ||||
| f, | f, | ||||
| ) | ) | ||||
| if p2 not in seen and p2 != nullid: | if p2 not in seen and p2 != self.repo.nullid: | ||||
| self._err( | self._err( | ||||
| lr, | lr, | ||||
| _(b"unknown parent 2 %s of %s") % (short(p2), short(node)), | _(b"unknown parent 2 %s of %s") % (short(p2), short(node)), | ||||
| f, | f, | ||||
| ) | ) | ||||
| except Exception as inst: | except Exception as inst: | ||||
| self._exc(lr, _(b"checking parents of %s") % short(node), inst, f) | self._exc(lr, _(b"checking parents of %s") % short(node), inst, f) | ||||
| ) | ) | ||||
| for i in repo: | for i in repo: | ||||
| progress.update(i) | progress.update(i) | ||||
| n = cl.node(i) | n = cl.node(i) | ||||
| self._checkentry(cl, i, n, seen, [i], b"changelog") | self._checkentry(cl, i, n, seen, [i], b"changelog") | ||||
| try: | try: | ||||
| changes = cl.read(n) | changes = cl.read(n) | ||||
| if changes[0] != nullid: | if changes[0] != self.repo.nullid: | ||||
| mflinkrevs.setdefault(changes[0], []).append(i) | mflinkrevs.setdefault(changes[0], []).append(i) | ||||
| self.refersmf = True | self.refersmf = True | ||||
| for f in changes[3]: | for f in changes[3]: | ||||
| if match(f): | if match(f): | ||||
| filelinkrevs.setdefault(_normpath(f), []).append(i) | filelinkrevs.setdefault(_normpath(f), []).append(i) | ||||
| except Exception as inst: | except Exception as inst: | ||||
| self.refersmf = True | self.refersmf = True | ||||
| self._exc(i, _(b"unpacking changeset %s") % short(n), inst) | self._exc(i, _(b"unpacking changeset %s") % short(n), inst) | ||||
| lr, | lr, | ||||
| _( | _( | ||||
| b"empty or missing copy source revlog " | b"empty or missing copy source revlog " | ||||
| b"%s:%s" | b"%s:%s" | ||||
| ) | ) | ||||
| % (rp[0], short(rp[1])), | % (rp[0], short(rp[1])), | ||||
| f, | f, | ||||
| ) | ) | ||||
| elif rp[1] == nullid: | elif rp[1] == self.repo.nullid: | ||||
| ui.note( | ui.note( | ||||
| _( | _( | ||||
| b"warning: %s@%s: copy source" | b"warning: %s@%s: copy source" | ||||
| b" revision is nullid %s:%s\n" | b" revision is nullid %s:%s\n" | ||||
| ) | ) | ||||
| % (f, lr, rp[0], short(rp[1])) | % (f, lr, rp[0], short(rp[1])) | ||||
| ) | ) | ||||
| else: | else: | ||||
| # wireprotov1server.py - Wire protocol version 1 server functionality | # wireprotov1server.py - Wire protocol version 1 server functionality | ||||
| # | # | ||||
| # Copyright 2005-2010 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2010 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import binascii | import binascii | ||||
| import os | import os | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import hex | ||||
| hex, | |||||
| nullid, | |||||
| ) | |||||
| from .pycompat import getattr | from .pycompat import getattr | ||||
| from . import ( | from . import ( | ||||
| bundle2, | bundle2, | ||||
| bundlecaches, | bundlecaches, | ||||
| changegroup as changegroupmod, | changegroup as changegroupmod, | ||||
| discovery, | discovery, | ||||
| encoding, | encoding, | ||||
| if proto.name == b'http-v1': | if proto.name == b'http-v1': | ||||
| return wireprototypes.ooberror(bundle2required) | return wireprototypes.ooberror(bundle2required) | ||||
| raise error.Abort(bundle2requiredmain, hint=bundle2requiredhint) | raise error.Abort(bundle2requiredmain, hint=bundle2requiredhint) | ||||
| try: | try: | ||||
| clheads = set(repo.changelog.heads()) | clheads = set(repo.changelog.heads()) | ||||
| heads = set(opts.get(b'heads', set())) | heads = set(opts.get(b'heads', set())) | ||||
| common = set(opts.get(b'common', set())) | common = set(opts.get(b'common', set())) | ||||
| common.discard(nullid) | common.discard(repo.nullid) | ||||
| if ( | if ( | ||||
| repo.ui.configbool(b'server', b'pullbundle') | repo.ui.configbool(b'server', b'pullbundle') | ||||
| and b'partial-pull' in proto.getprotocaps() | and b'partial-pull' in proto.getprotocaps() | ||||
| ): | ): | ||||
| # Check if a pre-built bundle covers this request. | # Check if a pre-built bundle covers this request. | ||||
| bundle = find_pullbundle(repo, proto, opts, clheads, heads, common) | bundle = find_pullbundle(repo, proto, opts, clheads, heads, common) | ||||
| if bundle: | if bundle: | ||||
| return wireprototypes.streamres( | return wireprototypes.streamres( | ||||
| # Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> | # Copyright 21 May 2005 - (c) 2005 Jake Edge <jake@edge2.net> | ||||
| # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | # Copyright 2005-2007 Olivia Mackall <olivia@selenic.com> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import collections | import collections | ||||
| import contextlib | import contextlib | ||||
| from .i18n import _ | from .i18n import _ | ||||
| from .node import ( | from .node import hex | ||||
| hex, | |||||
| nullid, | |||||
| ) | |||||
| from . import ( | from . import ( | ||||
| discovery, | discovery, | ||||
| encoding, | encoding, | ||||
| error, | error, | ||||
| match as matchmod, | match as matchmod, | ||||
| narrowspec, | narrowspec, | ||||
| pycompat, | pycompat, | ||||
| streamclone, | streamclone, | ||||
| if not spec[b'heads']: | if not spec[b'heads']: | ||||
| raise error.WireprotoCommandError( | raise error.WireprotoCommandError( | ||||
| b'heads key in changesetdagrange cannot be empty' | b'heads key in changesetdagrange cannot be empty' | ||||
| ) | ) | ||||
| if spec[b'roots']: | if spec[b'roots']: | ||||
| common = [n for n in spec[b'roots'] if clhasnode(n)] | common = [n for n in spec[b'roots'] if clhasnode(n)] | ||||
| else: | else: | ||||
| common = [nullid] | common = [repo.nullid] | ||||
| for n in discovery.outgoing(repo, common, spec[b'heads']).missing: | for n in discovery.outgoing(repo, common, spec[b'heads']).missing: | ||||
| if n not in seen: | if n not in seen: | ||||
| nodes.append(n) | nodes.append(n) | ||||
| seen.add(n) | seen.add(n) | ||||
| else: | else: | ||||
| raise error.WireprotoCommandError( | raise error.WireprotoCommandError( | ||||
| # prune: A, B, C # many to nothing | # prune: A, B, C # many to nothing | ||||
| """ | """ | ||||
| from __future__ import absolute_import, print_function | from __future__ import absolute_import, print_function | ||||
| import collections | import collections | ||||
| import itertools | import itertools | ||||
| import re | import re | ||||
| from mercurial.node import nullid | |||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial import ( | from mercurial import ( | ||||
| context, | context, | ||||
| error, | error, | ||||
| obsolete, | obsolete, | ||||
| pycompat, | pycompat, | ||||
| registrar, | registrar, | ||||
| scmutil, | scmutil, | ||||
| 'changes': scmutil.status([], list(added), [], [], [], [], []), | 'changes': scmutil.status([], list(added), [], [], [], [], []), | ||||
| 'date': b'0 0', | 'date': b'0 0', | ||||
| 'extra': {b'branch': b'default'}, | 'extra': {b'branch': b'default'}, | ||||
| } | } | ||||
| super(simplecommitctx, self).__init__(repo, name, **opts) | super(simplecommitctx, self).__init__(repo, name, **opts) | ||||
| self._added = added | self._added = added | ||||
| self._parents = parentctxs | self._parents = parentctxs | ||||
| while len(self._parents) < 2: | while len(self._parents) < 2: | ||||
| self._parents.append(repo[nullid]) | self._parents.append(repo[repo.nullid]) | ||||
| def filectx(self, key): | def filectx(self, key): | ||||
| return simplefilectx(key, self._added[key]) | return simplefilectx(key, self._added[key]) | ||||
| def commit(self): | def commit(self): | ||||
| return self._repo.commitctx(self) | return self._repo.commitctx(self) | ||||
| def p1copies(self): | def p1copies(self): | ||||
| # parse comments to get extra file content instructions | # parse comments to get extra file content instructions | ||||
| files = collections.defaultdict(dict) # {(name, path): content} | files = collections.defaultdict(dict) # {(name, path): content} | ||||
| comments = list(_getcomments(text)) | comments = list(_getcomments(text)) | ||||
| filere = re.compile(br'^(\w+)/([\w/]+)\s*=\s*(.*)$', re.M) | filere = re.compile(br'^(\w+)/([\w/]+)\s*=\s*(.*)$', re.M) | ||||
| for name, path, content in filere.findall(b'\n'.join(comments)): | for name, path, content in filere.findall(b'\n'.join(comments)): | ||||
| content = content.replace(br'\n', b'\n').replace(br'\1', b'\1') | content = content.replace(br'\n', b'\n').replace(br'\1', b'\1') | ||||
| files[name][path] = content | files[name][path] = content | ||||
| committed = {None: nullid} # {name: node} | committed = {None: repo.nullid} # {name: node} | ||||
| # for leaf nodes, try to find existing nodes in repo | # for leaf nodes, try to find existing nodes in repo | ||||
| for name, parents in edges.items(): | for name, parents in edges.items(): | ||||
| if len(parents) == 0: | if len(parents) == 0: | ||||
| try: | try: | ||||
| committed[name] = scmutil.revsingle(repo, name) | committed[name] = scmutil.revsingle(repo, name) | ||||
| except error.RepoLookupError: | except error.RepoLookupError: | ||||
| pass | pass | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import stat | import stat | ||||
| from mercurial.i18n import _ | from mercurial.i18n import _ | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| ) | ) | ||||
| from mercurial.thirdparty import attr | from mercurial.thirdparty import attr | ||||
| from mercurial import ( | from mercurial import ( | ||||
| ancestor, | ancestor, | ||||
| bundlerepo, | bundlerepo, | ||||
| error, | error, | ||||
| extensions, | extensions, | ||||
| self._indexbynode.clear() | self._indexbynode.clear() | ||||
| self._indexbyrev.clear() | self._indexbyrev.clear() | ||||
| self._index = [] | self._index = [] | ||||
| for i, entry in enumerate(self._indexdata): | for i, entry in enumerate(self._indexdata): | ||||
| self._indexbynode[entry[b'node']] = entry | self._indexbynode[entry[b'node']] = entry | ||||
| self._indexbyrev[i] = entry | self._indexbyrev[i] = entry | ||||
| self._indexbynode[nullid] = { | self._indexbynode[self._repo.nullid] = { | ||||
| b'node': nullid, | b'node': self._repo.nullid, | ||||
| b'p1': nullid, | b'p1': self._repo.nullid, | ||||
| b'p2': nullid, | b'p2': self._repo.nullid, | ||||
| b'linkrev': nullrev, | b'linkrev': nullrev, | ||||
| b'flags': 0, | b'flags': 0, | ||||
| } | } | ||||
| self._indexbyrev[nullrev] = { | self._indexbyrev[nullrev] = { | ||||
| b'node': nullid, | b'node': self._repo.nullid, | ||||
| b'p1': nullid, | b'p1': self._repo.nullid, | ||||
| b'p2': nullid, | b'p2': self._repo.nullid, | ||||
| b'linkrev': nullrev, | b'linkrev': nullrev, | ||||
| b'flags': 0, | b'flags': 0, | ||||
| } | } | ||||
| for i, entry in enumerate(self._indexdata): | for i, entry in enumerate(self._indexdata): | ||||
| p1rev, p2rev = self.parentrevs(self.rev(entry[b'node'])) | p1rev, p2rev = self.parentrevs(self.rev(entry[b'node'])) | ||||
| # start, length, rawsize, chainbase, linkrev, p1, p2, node | # start, length, rawsize, chainbase, linkrev, p1, p2, node | ||||
| self._index.append( | self._index.append( | ||||
| (0, 0, 0, -1, entry[b'linkrev'], p1rev, p2rev, entry[b'node']) | (0, 0, 0, -1, entry[b'linkrev'], p1rev, p2rev, entry[b'node']) | ||||
| ) | ) | ||||
| self._index.append((0, 0, 0, -1, -1, -1, -1, nullid)) | self._index.append((0, 0, 0, -1, -1, -1, -1, self._repo.nullid)) | ||||
| def __len__(self): | def __len__(self): | ||||
| return len(self._indexdata) | return len(self._indexdata) | ||||
| def __iter__(self): | def __iter__(self): | ||||
| return iter(range(len(self))) | return iter(range(len(self))) | ||||
| def revs(self, start=0, stop=None): | def revs(self, start=0, stop=None): | ||||
| def revision(self, nodeorrev, raw=False): | def revision(self, nodeorrev, raw=False): | ||||
| if isinstance(nodeorrev, int): | if isinstance(nodeorrev, int): | ||||
| node = self.node(nodeorrev) | node = self.node(nodeorrev) | ||||
| else: | else: | ||||
| node = nodeorrev | node = nodeorrev | ||||
| validatenode(node) | validatenode(node) | ||||
| if node == nullid: | if node == self._repo.nullid: | ||||
| return b'' | return b'' | ||||
| rev = self.rev(node) | rev = self.rev(node) | ||||
| flags = self._flags(rev) | flags = self._flags(rev) | ||||
| path = b'/'.join([self._storepath, hex(node)]) | path = b'/'.join([self._storepath, hex(node)]) | ||||
| rawtext = self._svfs.read(path) | rawtext = self._svfs.read(path) | ||||
| return revision | return revision | ||||
| start = revision.index(b'\1\n', 2) | start = revision.index(b'\1\n', 2) | ||||
| return revision[start + 2 :] | return revision[start + 2 :] | ||||
| def renamed(self, node): | def renamed(self, node): | ||||
| validatenode(node) | validatenode(node) | ||||
| if self.parents(node)[0] != nullid: | if self.parents(node)[0] != self._repo.nullid: | ||||
| return False | return False | ||||
| fulltext = self.revision(node) | fulltext = self.revision(node) | ||||
| m = storageutil.parsemeta(fulltext)[0] | m = storageutil.parsemeta(fulltext)[0] | ||||
| if m and 'copy' in m: | if m and 'copy' in m: | ||||
| return m['copy'], bin(m['copyrev']) | return m['copy'], bin(m['copyrev']) | ||||
| nodes, | nodes, | ||||
| nodesorder=None, | nodesorder=None, | ||||
| revisiondata=False, | revisiondata=False, | ||||
| assumehaveparentrevisions=False, | assumehaveparentrevisions=False, | ||||
| deltamode=repository.CG_DELTAMODE_STD, | deltamode=repository.CG_DELTAMODE_STD, | ||||
| sidedata_helpers=None, | sidedata_helpers=None, | ||||
| ): | ): | ||||
| # TODO this will probably break on some ordering options. | # TODO this will probably break on some ordering options. | ||||
| nodes = [n for n in nodes if n != nullid] | nodes = [n for n in nodes if n != self._repo.nullid] | ||||
| if not nodes: | if not nodes: | ||||
| return | return | ||||
| for delta in storageutil.emitrevisions( | for delta in storageutil.emitrevisions( | ||||
| self, | self, | ||||
| nodes, | nodes, | ||||
| nodesorder, | nodesorder, | ||||
| simplestorerevisiondelta, | simplestorerevisiondelta, | ||||
| revisiondata=revisiondata, | revisiondata=revisiondata, | ||||
| if node in self._indexbynode: | if node in self._indexbynode: | ||||
| if duplicaterevisioncb: | if duplicaterevisioncb: | ||||
| duplicaterevisioncb(self, self.rev(node)) | duplicaterevisioncb(self, self.rev(node)) | ||||
| empty = False | empty = False | ||||
| continue | continue | ||||
| # Need to resolve the fulltext from the delta base. | # Need to resolve the fulltext from the delta base. | ||||
| if deltabase == nullid: | if deltabase == self._repo.nullid: | ||||
| text = mdiff.patch(b'', delta) | text = mdiff.patch(b'', delta) | ||||
| else: | else: | ||||
| text = mdiff.patch(self.revision(deltabase), delta) | text = mdiff.patch(self.revision(deltabase), delta) | ||||
| rev = self._addrawrevision( | rev = self._addrawrevision( | ||||
| node, text, transaction, linkrev, p1, p2, flags | node, text, transaction, linkrev, p1, p2, flags | ||||
| ) | ) | ||||
| revishead[self.rev(entry[b'p2'])] = False | revishead[self.rev(entry[b'p2'])] = False | ||||
| return [rev for rev, ishead in sorted(revishead.items()) if ishead] | return [rev for rev, ishead in sorted(revishead.items()) if ishead] | ||||
| def heads(self, start=None, stop=None): | def heads(self, start=None, stop=None): | ||||
| # This is copied from revlog.py. | # This is copied from revlog.py. | ||||
| if start is None and stop is None: | if start is None and stop is None: | ||||
| if not len(self): | if not len(self): | ||||
| return [nullid] | return [self._repo.nullid] | ||||
| return [self.node(r) for r in self._headrevs()] | return [self.node(r) for r in self._headrevs()] | ||||
| if start is None: | if start is None: | ||||
| start = nullid | start = self._repo.nullid | ||||
| if stop is None: | if stop is None: | ||||
| stop = [] | stop = [] | ||||
| stoprevs = {self.rev(n) for n in stop} | stoprevs = {self.rev(n) for n in stop} | ||||
| startrev = self.rev(start) | startrev = self.rev(start) | ||||
| reachable = {startrev} | reachable = {startrev} | ||||
| heads = {startrev} | heads = {startrev} | ||||
| parentrevs = self.parentrevs | parentrevs = self.parentrevs | ||||
| to reproduce the situation with recent Mercurial, this script uses (1) | to reproduce the situation with recent Mercurial, this script uses (1) | ||||
| "hg debugsetparents" to merge without ancestor check by "hg merge", | "hg debugsetparents" to merge without ancestor check by "hg merge", | ||||
| and (2) the extension to allow filelog merging between the revision | and (2) the extension to allow filelog merging between the revision | ||||
| and its ancestor by overriding "repo._filecommit". | and its ancestor by overriding "repo._filecommit". | ||||
| $ cat > ../legacyrepo.py <<EOF | $ cat > ../legacyrepo.py <<EOF | ||||
| > from __future__ import absolute_import | > from __future__ import absolute_import | ||||
| > from mercurial import commit, error, extensions, node | > from mercurial import commit, error, extensions | ||||
| > def _filecommit(orig, repo, fctx, manifest1, manifest2, | > def _filecommit(orig, repo, fctx, manifest1, manifest2, | ||||
| > linkrev, tr, includecopymeta, ms): | > linkrev, tr, includecopymeta, ms): | ||||
| > fname = fctx.path() | > fname = fctx.path() | ||||
| > text = fctx.data() | > text = fctx.data() | ||||
| > flog = repo.file(fname) | > flog = repo.file(fname) | ||||
| > fparent1 = manifest1.get(fname, node.nullid) | > fparent1 = manifest1.get(fname, repo.nullid) | ||||
| > fparent2 = manifest2.get(fname, node.nullid) | > fparent2 = manifest2.get(fname, repo.nullid) | ||||
| > meta = {} | > meta = {} | ||||
| > copy = fctx.copysource() | > copy = fctx.copysource() | ||||
| > if copy and copy != fname: | > if copy and copy != fname: | ||||
| > raise error.Abort('copying is not supported') | > raise error.Abort('copying is not supported') | ||||
| > if fparent2 != node.nullid: | > if fparent2 != repo.nullid: | ||||
| > return flog.add(text, meta, tr, linkrev, | > return flog.add(text, meta, tr, linkrev, | ||||
| > fparent1, fparent2), 'modified' | > fparent1, fparent2), 'modified' | ||||
| > raise error.Abort('only merging is supported') | > raise error.Abort('only merging is supported') | ||||
| > def uisetup(ui): | > def uisetup(ui): | ||||
| > extensions.wrapfunction(commit, '_filecommit', _filecommit) | > extensions.wrapfunction(commit, '_filecommit', _filecommit) | ||||
| > EOF | > EOF | ||||
| $ cat > baz <<EOF | $ cat > baz <<EOF | ||||
| description: | description: | ||||
| empty commit | empty commit | ||||
| verify pathauditor blocks evil filepaths | verify pathauditor blocks evil filepaths | ||||
| $ cat > evil-commit.py <<EOF | $ cat > evil-commit.py <<EOF | ||||
| > from __future__ import absolute_import | > from __future__ import absolute_import | ||||
| > from mercurial import context, hg, node, ui as uimod | > from mercurial import context, hg, ui as uimod | ||||
| > notrc = u".h\u200cg".encode('utf-8') + b'/hgrc' | > notrc = u".h\u200cg".encode('utf-8') + b'/hgrc' | ||||
| > u = uimod.ui.load() | > u = uimod.ui.load() | ||||
| > r = hg.repository(u, b'.') | > r = hg.repository(u, b'.') | ||||
| > def filectxfn(repo, memctx, path): | > def filectxfn(repo, memctx, path): | ||||
| > return context.memfilectx(repo, memctx, path, | > return context.memfilectx(repo, memctx, path, | ||||
| > b'[hooks]\nupdate = echo owned') | > b'[hooks]\nupdate = echo owned') | ||||
| > c = context.memctx(r, [r.changelog.tip(), node.nullid], | > c = context.memctx(r, [r.changelog.tip(), r.nullid], | ||||
| > b'evil', [notrc], filectxfn, 0) | > b'evil', [notrc], filectxfn, 0) | ||||
| > r.commitctx(c) | > r.commitctx(c) | ||||
| > EOF | > EOF | ||||
| $ "$PYTHON" evil-commit.py | $ "$PYTHON" evil-commit.py | ||||
| #if windows | #if windows | ||||
| $ hg co --clean tip | $ hg co --clean tip | ||||
| abort: path contains illegal component: .h\xe2\x80\x8cg\\hgrc (esc) | abort: path contains illegal component: .h\xe2\x80\x8cg\\hgrc (esc) | ||||
| [255] | [255] | ||||
| #else | #else | ||||
| $ hg co --clean tip | $ hg co --clean tip | ||||
| abort: path contains illegal component: .h\xe2\x80\x8cg/hgrc (esc) | abort: path contains illegal component: .h\xe2\x80\x8cg/hgrc (esc) | ||||
| [255] | [255] | ||||
| #endif | #endif | ||||
| $ hg rollback -f | $ hg rollback -f | ||||
| repository tip rolled back to revision 2 (undo commit) | repository tip rolled back to revision 2 (undo commit) | ||||
| $ cat > evil-commit.py <<EOF | $ cat > evil-commit.py <<EOF | ||||
| > from __future__ import absolute_import | > from __future__ import absolute_import | ||||
| > from mercurial import context, hg, node, ui as uimod | > from mercurial import context, hg, ui as uimod | ||||
| > notrc = b"HG~1/hgrc" | > notrc = b"HG~1/hgrc" | ||||
| > u = uimod.ui.load() | > u = uimod.ui.load() | ||||
| > r = hg.repository(u, b'.') | > r = hg.repository(u, b'.') | ||||
| > def filectxfn(repo, memctx, path): | > def filectxfn(repo, memctx, path): | ||||
| > return context.memfilectx(repo, memctx, path, | > return context.memfilectx(repo, memctx, path, | ||||
| > b'[hooks]\nupdate = echo owned') | > b'[hooks]\nupdate = echo owned') | ||||
| > c = context.memctx(r, [r[b'tip'].node(), node.nullid], | > c = context.memctx(r, [r[b'tip'].node(), r.nullid], | ||||
| > b'evil', [notrc], filectxfn, 0) | > b'evil', [notrc], filectxfn, 0) | ||||
| > r.commitctx(c) | > r.commitctx(c) | ||||
| > EOF | > EOF | ||||
| $ "$PYTHON" evil-commit.py | $ "$PYTHON" evil-commit.py | ||||
| $ hg co --clean tip | $ hg co --clean tip | ||||
| abort: path contains illegal component: HG~1/hgrc | abort: path contains illegal component: HG~1/hgrc | ||||
| [255] | [255] | ||||
| $ hg rollback -f | $ hg rollback -f | ||||
| repository tip rolled back to revision 2 (undo commit) | repository tip rolled back to revision 2 (undo commit) | ||||
| $ cat > evil-commit.py <<EOF | $ cat > evil-commit.py <<EOF | ||||
| > from __future__ import absolute_import | > from __future__ import absolute_import | ||||
| > from mercurial import context, hg, node, ui as uimod | > from mercurial import context, hg, ui as uimod | ||||
| > notrc = b"HG8B6C~2/hgrc" | > notrc = b"HG8B6C~2/hgrc" | ||||
| > u = uimod.ui.load() | > u = uimod.ui.load() | ||||
| > r = hg.repository(u, b'.') | > r = hg.repository(u, b'.') | ||||
| > def filectxfn(repo, memctx, path): | > def filectxfn(repo, memctx, path): | ||||
| > return context.memfilectx(repo, memctx, path, | > return context.memfilectx(repo, memctx, path, | ||||
| > b'[hooks]\nupdate = echo owned') | > b'[hooks]\nupdate = echo owned') | ||||
| > c = context.memctx(r, [r[b'tip'].node(), node.nullid], | > c = context.memctx(r, [r[b'tip'].node(), r.nullid], | ||||
| > b'evil', [notrc], filectxfn, 0) | > b'evil', [notrc], filectxfn, 0) | ||||
| > r.commitctx(c) | > r.commitctx(c) | ||||
| > EOF | > EOF | ||||
| $ "$PYTHON" evil-commit.py | $ "$PYTHON" evil-commit.py | ||||
| $ hg co --clean tip | $ hg co --clean tip | ||||
| abort: path contains illegal component: HG8B6C~2/hgrc | abort: path contains illegal component: HG8B6C~2/hgrc | ||||
| [255] | [255] | ||||
| to reproduce the situation with recent Mercurial, this script uses (1) | to reproduce the situation with recent Mercurial, this script uses (1) | ||||
| "hg debugsetparents" to merge without ancestor check by "hg merge", | "hg debugsetparents" to merge without ancestor check by "hg merge", | ||||
| and (2) the extension to allow filelog merging between the revision | and (2) the extension to allow filelog merging between the revision | ||||
| and its ancestor by overriding "repo._filecommit". | and its ancestor by overriding "repo._filecommit". | ||||
| $ cat > ../legacyrepo.py <<EOF | $ cat > ../legacyrepo.py <<EOF | ||||
| > from __future__ import absolute_import | > from __future__ import absolute_import | ||||
| > from mercurial import commit, error, extensions, node | > from mercurial import commit, error, extensions | ||||
| > def _filecommit(orig, repo, fctx, manifest1, manifest2, | > def _filecommit(orig, repo, fctx, manifest1, manifest2, | ||||
| > linkrev, tr, includecopymeta, ms): | > linkrev, tr, includecopymeta, ms): | ||||
| > fname = fctx.path() | > fname = fctx.path() | ||||
| > text = fctx.data() | > text = fctx.data() | ||||
| > flog = repo.file(fname) | > flog = repo.file(fname) | ||||
| > fparent1 = manifest1.get(fname, node.nullid) | > fparent1 = manifest1.get(fname, repo.nullid) | ||||
| > fparent2 = manifest2.get(fname, node.nullid) | > fparent2 = manifest2.get(fname, repo.nullid) | ||||
| > meta = {} | > meta = {} | ||||
| > copy = fctx.copysource() | > copy = fctx.copysource() | ||||
| > if copy and copy != fname: | > if copy and copy != fname: | ||||
| > raise error.Abort('copying is not supported') | > raise error.Abort('copying is not supported') | ||||
| > if fparent2 != node.nullid: | > if fparent2 != repo.nullid: | ||||
| > return flog.add(text, meta, tr, linkrev, | > return flog.add(text, meta, tr, linkrev, | ||||
| > fparent1, fparent2), 'modified' | > fparent1, fparent2), 'modified' | ||||
| > raise error.Abort('only merging is supported') | > raise error.Abort('only merging is supported') | ||||
| > def uisetup(ui): | > def uisetup(ui): | ||||
| > extensions.wrapfunction(commit, '_filecommit', _filecommit) | > extensions.wrapfunction(commit, '_filecommit', _filecommit) | ||||
| > EOF | > EOF | ||||
| $ cat > baz <<EOF | $ cat > baz <<EOF | ||||
| #!/usr/bin/env python3 | #!/usr/bin/env python3 | ||||
| """ | """ | ||||
| Tests the behavior of filelog w.r.t. data starting with '\1\n' | Tests the behavior of filelog w.r.t. data starting with '\1\n' | ||||
| """ | """ | ||||
| from __future__ import absolute_import, print_function | from __future__ import absolute_import, print_function | ||||
| from mercurial.node import ( | from mercurial.node import hex | ||||
| hex, | |||||
| nullid, | |||||
| ) | |||||
| from mercurial import ( | from mercurial import ( | ||||
| hg, | hg, | ||||
| ui as uimod, | ui as uimod, | ||||
| ) | ) | ||||
| myui = uimod.ui.load() | myui = uimod.ui.load() | ||||
| repo = hg.repository(myui, path=b'.', create=True) | repo = hg.repository(myui, path=b'.', create=True) | ||||
| fl = repo.file(b'foobar') | fl = repo.file(b'foobar') | ||||
| def addrev(text, renamed=False): | def addrev(text, renamed=False): | ||||
| if renamed: | if renamed: | ||||
| # data doesn't matter. Just make sure filelog.renamed() returns True | # data doesn't matter. Just make sure filelog.renamed() returns True | ||||
| meta = {b'copyrev': hex(nullid), b'copy': b'bar'} | meta = {b'copyrev': hex(repo.nullid), b'copy': b'bar'} | ||||
| else: | else: | ||||
| meta = {} | meta = {} | ||||
| lock = t = None | lock = t = None | ||||
| try: | try: | ||||
| lock = repo.lock() | lock = repo.lock() | ||||
| t = repo.transaction(b'commit') | t = repo.transaction(b'commit') | ||||
| node = fl.add(text, meta, t, 0, nullid, nullid) | node = fl.add(text, meta, t, 0, repo.nullid, repo.nullid) | ||||
| return node | return node | ||||
| finally: | finally: | ||||
| if t: | if t: | ||||
| t.close() | t.close() | ||||
| if lock: | if lock: | ||||
| lock.release() | lock.release() | ||||
| """This unit test primarily tests parsers.parse_index2(). | """This unit test primarily tests parsers.parse_index2(). | ||||
| It also checks certain aspects of the parsers module as a whole. | It also checks certain aspects of the parsers module as a whole. | ||||
| """ | """ | ||||
| from __future__ import absolute_import, print_function | from __future__ import absolute_import, print_function | ||||
| import os | import os | ||||
| import struct | import struct | ||||
| import subprocess | import subprocess | ||||
| import sys | import sys | ||||
| import unittest | import unittest | ||||
| from mercurial.node import ( | from mercurial.node import ( | ||||
| bin, | bin, | ||||
| hex, | hex, | ||||
| nullid, | |||||
| nullrev, | nullrev, | ||||
| sha1nodeconstants, | |||||
| ) | ) | ||||
| from mercurial import ( | from mercurial import ( | ||||
| policy, | policy, | ||||
| pycompat, | pycompat, | ||||
| ) | ) | ||||
| parsers = policy.importmod('parsers') | parsers = policy.importmod('parsers') | ||||
| # original python implementation | # original python implementation | ||||
| def gettype(q): | def gettype(q): | ||||
| return int(q & 0xFFFF) | return int(q & 0xFFFF) | ||||
| def offset_type(offset, type): | def offset_type(offset, type): | ||||
| return int(int(offset) << 16 | type) | return int(int(offset) << 16 | type) | ||||
| indexformatng = ">Qiiiiii20s12x" | indexformatng = ">Qiiiiii20s12x" | ||||
| def py_parseindex(data, inline): | def py_parseindex(data, inline): | ||||
| s = 64 | s = 64 | ||||
| cache = None | cache = None | ||||
| index = [] | index = [] | ||||
| nodemap = {nullid: nullrev} | nodemap = {sha1nodeconstants.nullid: nullrev} | ||||
| n = off = 0 | n = off = 0 | ||||
| l = len(data) - s | l = len(data) - s | ||||
| append = index.append | append = index.append | ||||
| if inline: | if inline: | ||||
| cache = (0, data) | cache = (0, data) | ||||
| while off <= l: | while off <= l: | ||||
| e = struct.unpack(indexformatng, data[off : off + s]) | e = struct.unpack(indexformatng, data[off : off + s]) | ||||
| self.assertEqual(want, got) # inline data | self.assertEqual(want, got) # inline data | ||||
| want = py_parseindex(data_non_inlined, False) | want = py_parseindex(data_non_inlined, False) | ||||
| got = parse_index2(data_non_inlined, False) | got = parse_index2(data_non_inlined, False) | ||||
| self.assertEqual(want, got) # no inline data | self.assertEqual(want, got) # no inline data | ||||
| ix = parsers.parse_index2(data_inlined, True)[0] | ix = parsers.parse_index2(data_inlined, True)[0] | ||||
| for i, r in enumerate(ix): | for i, r in enumerate(ix): | ||||
| if r[7] == nullid: | if r[7] == sha1nodeconstants.nullid: | ||||
| i = -1 | i = -1 | ||||
| try: | try: | ||||
| self.assertEqual( | self.assertEqual( | ||||
| ix[r[7]], | ix[r[7]], | ||||
| i, | i, | ||||
| 'Reverse lookup inconsistent for %r' % hex(r[7]), | 'Reverse lookup inconsistent for %r' % hex(r[7]), | ||||
| ) | ) | ||||
| except TypeError: | except TypeError: | ||||
| # pure version doesn't support this | # pure version doesn't support this | ||||
| break | break | ||||
| def testminusone(self): | def testminusone(self): | ||||
| want = (0, 0, 0, -1, -1, -1, -1, nullid) | want = (0, 0, 0, -1, -1, -1, -1, sha1nodeconstants.nullid) | ||||
| index, junk = parsers.parse_index2(data_inlined, True) | index, junk = parsers.parse_index2(data_inlined, True) | ||||
| got = index[-1] | got = index[-1] | ||||
| self.assertEqual(want, got) # inline data | self.assertEqual(want, got) # inline data | ||||
| index, junk = parsers.parse_index2(data_non_inlined, False) | index, junk = parsers.parse_index2(data_non_inlined, False) | ||||
| got = index[-1] | got = index[-1] | ||||
| self.assertEqual(want, got) # no inline data | self.assertEqual(want, got) # no inline data | ||||
| import tempfile | import tempfile | ||||
| import time | import time | ||||
| import unittest | import unittest | ||||
| import silenttestrunner | import silenttestrunner | ||||
| # Load the local remotefilelog, not the system one | # Load the local remotefilelog, not the system one | ||||
| sys.path[0:0] = [os.path.join(os.path.dirname(__file__), '..')] | sys.path[0:0] = [os.path.join(os.path.dirname(__file__), '..')] | ||||
| from mercurial.node import nullid | from mercurial.node import sha1nodeconstants | ||||
| from mercurial import policy | from mercurial import policy | ||||
| if not policy._packageprefs.get(policy.policy, (False, False))[1]: | if not policy._packageprefs.get(policy.policy, (False, False))[1]: | ||||
| if __name__ == '__main__': | if __name__ == '__main__': | ||||
| msg = "skipped: pure module not available with module policy:" | msg = "skipped: pure module not available with module policy:" | ||||
| print(msg, policy.policy, file=sys.stderr) | print(msg, policy.policy, file=sys.stderr) | ||||
| sys.exit(80) | sys.exit(80) | ||||
| def getFakeHash(self): | def getFakeHash(self): | ||||
| return b''.join( | return b''.join( | ||||
| pycompat.bytechr(random.randint(0, 255)) for _ in range(20) | pycompat.bytechr(random.randint(0, 255)) for _ in range(20) | ||||
| ) | ) | ||||
| def createPack(self, revisions=None, packdir=None): | def createPack(self, revisions=None, packdir=None): | ||||
| if revisions is None: | if revisions is None: | ||||
| revisions = [(b"filename", self.getFakeHash(), nullid, b"content")] | revisions = [ | ||||
| ( | |||||
| b"filename", | |||||
| self.getFakeHash(), | |||||
| sha1nodeconstants.nullid, | |||||
| b"content", | |||||
| ) | |||||
| ] | |||||
| if packdir is None: | if packdir is None: | ||||
| packdir = self.makeTempDir() | packdir = self.makeTempDir() | ||||
| packer = datapack.mutabledatapack(uimod.ui(), packdir, version=2) | packer = datapack.mutabledatapack(uimod.ui(), packdir, version=2) | ||||
| for args in revisions: | for args in revisions: | ||||
| filename, node, base, content = args[0:4] | filename, node, base, content = args[0:4] | ||||
| # meta is optional | # meta is optional | ||||
| meta = None | meta = None | ||||
| if len(args) > 4: | if len(args) > 4: | ||||
| meta = args[4] | meta = args[4] | ||||
| packer.add(filename, node, base, content, metadata=meta) | packer.add(filename, node, base, content, metadata=meta) | ||||
| path = packer.close() | path = packer.close() | ||||
| return self.datapackreader(path) | return self.datapackreader(path) | ||||
| def _testAddSingle(self, content): | def _testAddSingle(self, content): | ||||
| """Test putting a simple blob into a pack and reading it out.""" | """Test putting a simple blob into a pack and reading it out.""" | ||||
| filename = b"foo" | filename = b"foo" | ||||
| node = self.getHash(content) | node = self.getHash(content) | ||||
| revisions = [(filename, node, nullid, content)] | revisions = [(filename, node, sha1nodeconstants.nullid, content)] | ||||
| pack = self.createPack(revisions) | pack = self.createPack(revisions) | ||||
| if self.paramsavailable: | if self.paramsavailable: | ||||
| self.assertEqual( | self.assertEqual( | ||||
| pack.params.fanoutprefix, basepack.SMALLFANOUTPREFIX | pack.params.fanoutprefix, basepack.SMALLFANOUTPREFIX | ||||
| ) | ) | ||||
| chain = pack.getdeltachain(filename, node) | chain = pack.getdeltachain(filename, node) | ||||
| self.assertEqual(content, chain[0][4]) | self.assertEqual(content, chain[0][4]) | ||||
| chain = pack.getdeltachain(filename, node) | chain = pack.getdeltachain(filename, node) | ||||
| self.assertEqual(content, chain[0][4]) | self.assertEqual(content, chain[0][4]) | ||||
| def testAddDeltas(self): | def testAddDeltas(self): | ||||
| """Test putting multiple delta blobs into a pack and read the chain.""" | """Test putting multiple delta blobs into a pack and read the chain.""" | ||||
| revisions = [] | revisions = [] | ||||
| filename = b"foo" | filename = b"foo" | ||||
| lastnode = nullid | lastnode = sha1nodeconstants.nullid | ||||
| for i in range(10): | for i in range(10): | ||||
| content = b"abcdef%d" % i | content = b"abcdef%d" % i | ||||
| node = self.getHash(content) | node = self.getHash(content) | ||||
| revisions.append((filename, node, lastnode, content)) | revisions.append((filename, node, lastnode, content)) | ||||
| lastnode = node | lastnode = node | ||||
| pack = self.createPack(revisions) | pack = self.createPack(revisions) | ||||
| blobs = {} | blobs = {} | ||||
| random.seed(0) | random.seed(0) | ||||
| for i in range(100): | for i in range(100): | ||||
| filename = b"filename-%d" % i | filename = b"filename-%d" % i | ||||
| filerevs = [] | filerevs = [] | ||||
| for j in range(random.randint(1, 100)): | for j in range(random.randint(1, 100)): | ||||
| content = b"content-%d" % j | content = b"content-%d" % j | ||||
| node = self.getHash(content) | node = self.getHash(content) | ||||
| lastnode = nullid | lastnode = sha1nodeconstants.nullid | ||||
| if len(filerevs) > 0: | if len(filerevs) > 0: | ||||
| lastnode = filerevs[random.randint(0, len(filerevs) - 1)] | lastnode = filerevs[random.randint(0, len(filerevs) - 1)] | ||||
| filerevs.append(node) | filerevs.append(node) | ||||
| blobs[(filename, node, lastnode)] = content | blobs[(filename, node, lastnode)] = content | ||||
| revisions.append((filename, node, lastnode, content)) | revisions.append((filename, node, lastnode, content)) | ||||
| pack = self.createPack(revisions) | pack = self.createPack(revisions) | ||||
| content = b'put-something-here \n' * i | content = b'put-something-here \n' * i | ||||
| node = self.getHash(content) | node = self.getHash(content) | ||||
| meta = { | meta = { | ||||
| constants.METAKEYFLAG: i ** 4, | constants.METAKEYFLAG: i ** 4, | ||||
| constants.METAKEYSIZE: len(content), | constants.METAKEYSIZE: len(content), | ||||
| b'Z': b'random_string', | b'Z': b'random_string', | ||||
| b'_': b'\0' * i, | b'_': b'\0' * i, | ||||
| } | } | ||||
| revisions.append((filename, node, nullid, content, meta)) | revisions.append( | ||||
| (filename, node, sha1nodeconstants.nullid, content, meta) | |||||
| ) | |||||
| pack = self.createPack(revisions) | pack = self.createPack(revisions) | ||||
| for name, node, x, content, origmeta in revisions: | for name, node, x, content, origmeta in revisions: | ||||
| parsedmeta = pack.getmeta(name, node) | parsedmeta = pack.getmeta(name, node) | ||||
| # flag == 0 should be optimized out | # flag == 0 should be optimized out | ||||
| if origmeta[constants.METAKEYFLAG] == 0: | if origmeta[constants.METAKEYFLAG] == 0: | ||||
| del origmeta[constants.METAKEYFLAG] | del origmeta[constants.METAKEYFLAG] | ||||
| self.assertEqual(parsedmeta, origmeta) | self.assertEqual(parsedmeta, origmeta) | ||||
| def testGetMissing(self): | def testGetMissing(self): | ||||
| """Test the getmissing() api.""" | """Test the getmissing() api.""" | ||||
| revisions = [] | revisions = [] | ||||
| filename = b"foo" | filename = b"foo" | ||||
| lastnode = nullid | lastnode = sha1nodeconstants.nullid | ||||
| for i in range(10): | for i in range(10): | ||||
| content = b"abcdef%d" % i | content = b"abcdef%d" % i | ||||
| node = self.getHash(content) | node = self.getHash(content) | ||||
| revisions.append((filename, node, lastnode, content)) | revisions.append((filename, node, lastnode, content)) | ||||
| lastnode = node | lastnode = node | ||||
| pack = self.createPack(revisions) | pack = self.createPack(revisions) | ||||
| [(b"foo", revisions[0][1]), (b"foo", fakenode)] | [(b"foo", revisions[0][1]), (b"foo", fakenode)] | ||||
| ) | ) | ||||
| self.assertEqual(missing, [(b"foo", fakenode)]) | self.assertEqual(missing, [(b"foo", fakenode)]) | ||||
| def testAddThrows(self): | def testAddThrows(self): | ||||
| pack = self.createPack() | pack = self.createPack() | ||||
| try: | try: | ||||
| pack.add(b'filename', nullid, b'contents') | pack.add(b'filename', sha1nodeconstants.nullid, b'contents') | ||||
| self.assertTrue(False, "datapack.add should throw") | self.assertTrue(False, "datapack.add should throw") | ||||
| except RuntimeError: | except RuntimeError: | ||||
| pass | pass | ||||
| def testBadVersionThrows(self): | def testBadVersionThrows(self): | ||||
| pack = self.createPack() | pack = self.createPack() | ||||
| path = pack.path + b'.datapack' | path = pack.path + b'.datapack' | ||||
| with open(path, 'rb') as f: | with open(path, 'rb') as f: | ||||
| revisions = [] | revisions = [] | ||||
| blobs = {} | blobs = {} | ||||
| total = basepack.SMALLFANOUTCUTOFF + 1 | total = basepack.SMALLFANOUTCUTOFF + 1 | ||||
| for i in pycompat.xrange(total): | for i in pycompat.xrange(total): | ||||
| filename = b"filename-%d" % i | filename = b"filename-%d" % i | ||||
| content = filename | content = filename | ||||
| node = self.getHash(content) | node = self.getHash(content) | ||||
| blobs[(filename, node)] = content | blobs[(filename, node)] = content | ||||
| revisions.append((filename, node, nullid, content)) | revisions.append( | ||||
| (filename, node, sha1nodeconstants.nullid, content) | |||||
| ) | |||||
| pack = self.createPack(revisions) | pack = self.createPack(revisions) | ||||
| if self.paramsavailable: | if self.paramsavailable: | ||||
| self.assertEqual( | self.assertEqual( | ||||
| pack.params.fanoutprefix, basepack.LARGEFANOUTPREFIX | pack.params.fanoutprefix, basepack.LARGEFANOUTPREFIX | ||||
| ) | ) | ||||
| for (filename, node), content in blobs.items(): | for (filename, node), content in blobs.items(): | ||||
| actualcontent = pack.getdeltachain(filename, node)[0][4] | actualcontent = pack.getdeltachain(filename, node)[0][4] | ||||
| self.assertEqual(actualcontent, content) | self.assertEqual(actualcontent, content) | ||||
| def testPacksCache(self): | def testPacksCache(self): | ||||
| """Test that we remember the most recent packs while fetching the delta | """Test that we remember the most recent packs while fetching the delta | ||||
| chain.""" | chain.""" | ||||
| packdir = self.makeTempDir() | packdir = self.makeTempDir() | ||||
| deltachains = [] | deltachains = [] | ||||
| numpacks = 10 | numpacks = 10 | ||||
| revisionsperpack = 100 | revisionsperpack = 100 | ||||
| for i in range(numpacks): | for i in range(numpacks): | ||||
| chain = [] | chain = [] | ||||
| revision = (b'%d' % i, self.getFakeHash(), nullid, b"content") | revision = ( | ||||
| b'%d' % i, | |||||
| self.getFakeHash(), | |||||
| sha1nodeconstants.nullid, | |||||
| b"content", | |||||
| ) | |||||
| for _ in range(revisionsperpack): | for _ in range(revisionsperpack): | ||||
| chain.append(revision) | chain.append(revision) | ||||
| revision = ( | revision = ( | ||||
| b'%d' % i, | b'%d' % i, | ||||
| self.getFakeHash(), | self.getFakeHash(), | ||||
| revision[1], | revision[1], | ||||
| self.getFakeHash(), | self.getFakeHash(), | ||||
| 1000000, | 1000000, | ||||
| ] | ] | ||||
| for packsize in packsizes: | for packsize in packsizes: | ||||
| revisions = [] | revisions = [] | ||||
| for i in pycompat.xrange(packsize): | for i in pycompat.xrange(packsize): | ||||
| filename = b"filename-%d" % i | filename = b"filename-%d" % i | ||||
| content = b"content-%d" % i | content = b"content-%d" % i | ||||
| node = self.getHash(content) | node = self.getHash(content) | ||||
| revisions.append((filename, node, nullid, content)) | revisions.append( | ||||
| (filename, node, sha1nodeconstants.nullid, content) | |||||
| ) | |||||
| path = self.createPack(revisions).path | path = self.createPack(revisions).path | ||||
| # Perf of large multi-get | # Perf of large multi-get | ||||
| import gc | import gc | ||||
| gc.disable() | gc.disable() | ||||
| pack = self.datapackreader(path) | pack = self.datapackreader(path) | ||||
| #!/usr/bin/env python3 | #!/usr/bin/env python3 | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import hashlib | import hashlib | ||||
| import os | import os | ||||
| import random | import random | ||||
| import shutil | import shutil | ||||
| import stat | import stat | ||||
| import struct | import struct | ||||
| import sys | import sys | ||||
| import tempfile | import tempfile | ||||
| import unittest | import unittest | ||||
| import silenttestrunner | import silenttestrunner | ||||
| from mercurial.node import nullid | from mercurial.node import sha1nodeconstants | ||||
| from mercurial import ( | from mercurial import ( | ||||
| pycompat, | pycompat, | ||||
| ui as uimod, | ui as uimod, | ||||
| ) | ) | ||||
| # Load the local remotefilelog, not the system one | # Load the local remotefilelog, not the system one | ||||
| sys.path[0:0] = [os.path.join(os.path.dirname(__file__), '..')] | sys.path[0:0] = [os.path.join(os.path.dirname(__file__), '..')] | ||||
| from hgext.remotefilelog import ( | from hgext.remotefilelog import ( | ||||
| `revisions` is a list of tuples, where each tuple contains a filanem, | `revisions` is a list of tuples, where each tuple contains a filanem, | ||||
| node, p1node, p2node, and linknode. | node, p1node, p2node, and linknode. | ||||
| """ | """ | ||||
| if revisions is None: | if revisions is None: | ||||
| revisions = [ | revisions = [ | ||||
| ( | ( | ||||
| b"filename", | b"filename", | ||||
| self.getFakeHash(), | self.getFakeHash(), | ||||
| nullid, | sha1nodeconstants.nullid, | ||||
| nullid, | sha1nodeconstants.nullid, | ||||
| self.getFakeHash(), | self.getFakeHash(), | ||||
| None, | None, | ||||
| ) | ) | ||||
| ] | ] | ||||
| packdir = pycompat.fsencode(self.makeTempDir()) | packdir = pycompat.fsencode(self.makeTempDir()) | ||||
| packer = historypack.mutablehistorypack(uimod.ui(), packdir, version=2) | packer = historypack.mutablehistorypack(uimod.ui(), packdir, version=2) | ||||
| self.assertEqual(copyfrom, actual[3]) | self.assertEqual(copyfrom, actual[3]) | ||||
| def testAddAncestorChain(self): | def testAddAncestorChain(self): | ||||
| """Test putting multiple revisions in into a pack and read the ancestor | """Test putting multiple revisions in into a pack and read the ancestor | ||||
| chain. | chain. | ||||
| """ | """ | ||||
| revisions = [] | revisions = [] | ||||
| filename = b"foo" | filename = b"foo" | ||||
| lastnode = nullid | lastnode = sha1nodeconstants.nullid | ||||
| for i in range(10): | for i in range(10): | ||||
| node = self.getFakeHash() | node = self.getFakeHash() | ||||
| revisions.append((filename, node, lastnode, nullid, nullid, None)) | revisions.append( | ||||
| ( | |||||
| filename, | |||||
| node, | |||||
| lastnode, | |||||
| sha1nodeconstants.nullid, | |||||
| sha1nodeconstants.nullid, | |||||
| None, | |||||
| ) | |||||
| ) | |||||
| lastnode = node | lastnode = node | ||||
| # revisions must be added in topological order, newest first | # revisions must be added in topological order, newest first | ||||
| revisions = list(reversed(revisions)) | revisions = list(reversed(revisions)) | ||||
| pack = self.createPack(revisions) | pack = self.createPack(revisions) | ||||
| # Test that the chain has all the entries | # Test that the chain has all the entries | ||||
| ancestors = pack.getancestors(revisions[0][0], revisions[0][1]) | ancestors = pack.getancestors(revisions[0][0], revisions[0][1]) | ||||
| # Build a random pack file | # Build a random pack file | ||||
| allentries = {} | allentries = {} | ||||
| ancestorcounts = {} | ancestorcounts = {} | ||||
| revisions = [] | revisions = [] | ||||
| random.seed(0) | random.seed(0) | ||||
| for i in range(100): | for i in range(100): | ||||
| filename = b"filename-%d" % i | filename = b"filename-%d" % i | ||||
| entries = [] | entries = [] | ||||
| p2 = nullid | p2 = sha1nodeconstants.nullid | ||||
| linknode = nullid | linknode = sha1nodeconstants.nullid | ||||
| for j in range(random.randint(1, 100)): | for j in range(random.randint(1, 100)): | ||||
| node = self.getFakeHash() | node = self.getFakeHash() | ||||
| p1 = nullid | p1 = sha1nodeconstants.nullid | ||||
| if len(entries) > 0: | if len(entries) > 0: | ||||
| p1 = entries[random.randint(0, len(entries) - 1)] | p1 = entries[random.randint(0, len(entries) - 1)] | ||||
| entries.append(node) | entries.append(node) | ||||
| revisions.append((filename, node, p1, p2, linknode, None)) | revisions.append((filename, node, p1, p2, linknode, None)) | ||||
| allentries[(filename, node)] = (p1, p2, linknode) | allentries[(filename, node)] = (p1, p2, linknode) | ||||
| if p1 == nullid: | if p1 == sha1nodeconstants.nullid: | ||||
| ancestorcounts[(filename, node)] = 1 | ancestorcounts[(filename, node)] = 1 | ||||
| else: | else: | ||||
| newcount = ancestorcounts[(filename, p1)] + 1 | newcount = ancestorcounts[(filename, p1)] + 1 | ||||
| ancestorcounts[(filename, node)] = newcount | ancestorcounts[(filename, node)] = newcount | ||||
| # Must add file entries in reverse topological order | # Must add file entries in reverse topological order | ||||
| revisions = list(reversed(revisions)) | revisions = list(reversed(revisions)) | ||||
| pack = self.createPack(revisions) | pack = self.createPack(revisions) | ||||
| # Verify the pack contents | # Verify the pack contents | ||||
| for (filename, node) in allentries: | for (filename, node) in allentries: | ||||
| ancestors = pack.getancestors(filename, node) | ancestors = pack.getancestors(filename, node) | ||||
| self.assertEqual(ancestorcounts[(filename, node)], len(ancestors)) | self.assertEqual(ancestorcounts[(filename, node)], len(ancestors)) | ||||
| for anode, (ap1, ap2, alinknode, copyfrom) in ancestors.items(): | for anode, (ap1, ap2, alinknode, copyfrom) in ancestors.items(): | ||||
| ep1, ep2, elinknode = allentries[(filename, anode)] | ep1, ep2, elinknode = allentries[(filename, anode)] | ||||
| self.assertEqual(ap1, ep1) | self.assertEqual(ap1, ep1) | ||||
| self.assertEqual(ap2, ep2) | self.assertEqual(ap2, ep2) | ||||
| self.assertEqual(alinknode, elinknode) | self.assertEqual(alinknode, elinknode) | ||||
| self.assertEqual(copyfrom, None) | self.assertEqual(copyfrom, None) | ||||
| def testGetNodeInfo(self): | def testGetNodeInfo(self): | ||||
| revisions = [] | revisions = [] | ||||
| filename = b"foo" | filename = b"foo" | ||||
| lastnode = nullid | lastnode = sha1nodeconstants.nullid | ||||
| for i in range(10): | for i in range(10): | ||||
| node = self.getFakeHash() | node = self.getFakeHash() | ||||
| revisions.append((filename, node, lastnode, nullid, nullid, None)) | revisions.append( | ||||
| ( | |||||
| filename, | |||||
| node, | |||||
| lastnode, | |||||
| sha1nodeconstants.nullid, | |||||
| sha1nodeconstants.nullid, | |||||
| None, | |||||
| ) | |||||
| ) | |||||
| lastnode = node | lastnode = node | ||||
| pack = self.createPack(revisions) | pack = self.createPack(revisions) | ||||
| # Test that getnodeinfo returns the expected results | # Test that getnodeinfo returns the expected results | ||||
| for filename, node, p1, p2, linknode, copyfrom in revisions: | for filename, node, p1, p2, linknode, copyfrom in revisions: | ||||
| ap1, ap2, alinknode, acopyfrom = pack.getnodeinfo(filename, node) | ap1, ap2, alinknode, acopyfrom = pack.getnodeinfo(filename, node) | ||||
| self.assertEqual(ap1, p1) | self.assertEqual(ap1, p1) | ||||
| # Test getmissing on a non-existant filename | # Test getmissing on a non-existant filename | ||||
| missing = pack.getmissing([(b"bar", fakenode)]) | missing = pack.getmissing([(b"bar", fakenode)]) | ||||
| self.assertEqual(missing, [(b"bar", fakenode)]) | self.assertEqual(missing, [(b"bar", fakenode)]) | ||||
| def testAddThrows(self): | def testAddThrows(self): | ||||
| pack = self.createPack() | pack = self.createPack() | ||||
| try: | try: | ||||
| pack.add(b'filename', nullid, nullid, nullid, nullid, None) | pack.add( | ||||
| b'filename', | |||||
| sha1nodeconstants.nullid, | |||||
| sha1nodeconstants.nullid, | |||||
| sha1nodeconstants.nullid, | |||||
| sha1nodeconstants.nullid, | |||||
| None, | |||||
| ) | |||||
| self.assertTrue(False, "historypack.add should throw") | self.assertTrue(False, "historypack.add should throw") | ||||
| except RuntimeError: | except RuntimeError: | ||||
| pass | pass | ||||
| def testBadVersionThrows(self): | def testBadVersionThrows(self): | ||||
| pack = self.createPack() | pack = self.createPack() | ||||
| path = pack.path + b'.histpack' | path = pack.path + b'.histpack' | ||||
| with open(path, 'rb') as f: | with open(path, 'rb') as f: | ||||
| # test revlog interaction about raw data (flagprocessor) | # test revlog interaction about raw data (flagprocessor) | ||||
| from __future__ import absolute_import, print_function | from __future__ import absolute_import, print_function | ||||
| import collections | import collections | ||||
| import hashlib | import hashlib | ||||
| import sys | import sys | ||||
| from mercurial.node import nullid | |||||
| from mercurial import ( | from mercurial import ( | ||||
| encoding, | encoding, | ||||
| revlog, | revlog, | ||||
| transaction, | transaction, | ||||
| vfs, | vfs, | ||||
| ) | ) | ||||
| from mercurial.revlogutils import ( | from mercurial.revlogutils import ( | ||||
| def appendrev(rlog, text, tr, isext=False, isdelta=True): | def appendrev(rlog, text, tr, isext=False, isdelta=True): | ||||
| """Append a revision. If isext is True, set the EXTSTORED flag so flag | """Append a revision. If isext is True, set the EXTSTORED flag so flag | ||||
| processor will be used (and rawtext is different from text). If isdelta is | processor will be used (and rawtext is different from text). If isdelta is | ||||
| True, force the revision to be a delta, otherwise it's full text. | True, force the revision to be a delta, otherwise it's full text. | ||||
| """ | """ | ||||
| nextrev = len(rlog) | nextrev = len(rlog) | ||||
| p1 = rlog.node(nextrev - 1) | p1 = rlog.node(nextrev - 1) | ||||
| p2 = nullid | p2 = rlog.nullid | ||||
| if isext: | if isext: | ||||
| flags = revlog.REVIDX_EXTSTORED | flags = revlog.REVIDX_EXTSTORED | ||||
| else: | else: | ||||
| flags = revlog.REVIDX_DEFAULT_FLAGS | flags = revlog.REVIDX_DEFAULT_FLAGS | ||||
| # Change storedeltachains temporarily, to override revlog's delta decision | # Change storedeltachains temporarily, to override revlog's delta decision | ||||
| rlog._storedeltachains = isdelta | rlog._storedeltachains = isdelta | ||||
| try: | try: | ||||
| rlog.addrevision(text, tr, nextrev, p1, p2, flags=flags) | rlog.addrevision(text, tr, nextrev, p1, p2, flags=flags) | ||||
| This exercises some revlog.addgroup (and revlog._addrevision(text=None)) | This exercises some revlog.addgroup (and revlog._addrevision(text=None)) | ||||
| code path, which is not covered by "appendrev" alone. | code path, which is not covered by "appendrev" alone. | ||||
| """ | """ | ||||
| class dummychangegroup(object): | class dummychangegroup(object): | ||||
| @staticmethod | @staticmethod | ||||
| def deltachunk(pnode): | def deltachunk(pnode): | ||||
| pnode = pnode or nullid | pnode = pnode or rlog.nullid | ||||
| parentrev = rlog.rev(pnode) | parentrev = rlog.rev(pnode) | ||||
| r = parentrev + 1 | r = parentrev + 1 | ||||
| if r >= len(rlog): | if r >= len(rlog): | ||||
| return {} | return {} | ||||
| if optimaldelta: | if optimaldelta: | ||||
| deltaparent = parentrev | deltaparent = parentrev | ||||
| else: | else: | ||||
| # suboptimal deltaparent | # suboptimal deltaparent | ||||
| deltaparent = min(0, parentrev) | deltaparent = min(0, parentrev) | ||||
| if not rlog.candelta(deltaparent, r): | if not rlog.candelta(deltaparent, r): | ||||
| deltaparent = -1 | deltaparent = -1 | ||||
| return { | return { | ||||
| b'node': rlog.node(r), | b'node': rlog.node(r), | ||||
| b'p1': pnode, | b'p1': pnode, | ||||
| b'p2': nullid, | b'p2': rlog.nullid, | ||||
| b'cs': rlog.node(rlog.linkrev(r)), | b'cs': rlog.node(rlog.linkrev(r)), | ||||
| b'flags': rlog.flags(r), | b'flags': rlog.flags(r), | ||||
| b'deltabase': rlog.node(deltaparent), | b'deltabase': rlog.node(deltaparent), | ||||
| b'delta': rlog.revdiff(deltaparent, r), | b'delta': rlog.revdiff(deltaparent, r), | ||||
| b'sidedata': rlog.sidedata(r), | b'sidedata': rlog.sidedata(r), | ||||
| } | } | ||||
| def deltaiter(self): | def deltaiter(self): | ||||
| def lowlevelcopy(rlog, tr, destname=b'_destrevlog.i'): | def lowlevelcopy(rlog, tr, destname=b'_destrevlog.i'): | ||||
| """Like addgroupcopy, but use the low level revlog._addrevision directly. | """Like addgroupcopy, but use the low level revlog._addrevision directly. | ||||
| It exercises some code paths that are hard to reach easily otherwise. | It exercises some code paths that are hard to reach easily otherwise. | ||||
| """ | """ | ||||
| dlog = newrevlog(destname, recreate=True) | dlog = newrevlog(destname, recreate=True) | ||||
| for r in rlog: | for r in rlog: | ||||
| p1 = rlog.node(r - 1) | p1 = rlog.node(r - 1) | ||||
| p2 = nullid | p2 = rlog.nullid | ||||
| if r == 0 or (rlog.flags(r) & revlog.REVIDX_EXTSTORED): | if r == 0 or (rlog.flags(r) & revlog.REVIDX_EXTSTORED): | ||||
| text = rlog.rawdata(r) | text = rlog.rawdata(r) | ||||
| cachedelta = None | cachedelta = None | ||||
| else: | else: | ||||
| # deltaparent cannot have EXTSTORED flag. | # deltaparent cannot have EXTSTORED flag. | ||||
| deltaparent = max( | deltaparent = max( | ||||
| [-1] | [-1] | ||||
| + [ | + [ | ||||
| # ext-sidedata.py - small extension to test the sidedata logic | # ext-sidedata.py - small extension to test the sidedata logic | ||||
| # | # | ||||
| # Copyright 2019 Pierre-Yves David <pierre-yves.david@octobus.net> | # Copyright 2019 Pierre-Yves David <pierre-yves.david@octobus.net> | ||||
| # | # | ||||
| # This software may be used and distributed according to the terms of the | # This software may be used and distributed according to the terms of the | ||||
| # GNU General Public License version 2 or any later version. | # GNU General Public License version 2 or any later version. | ||||
| from __future__ import absolute_import | from __future__ import absolute_import | ||||
| import hashlib | import hashlib | ||||
| import struct | import struct | ||||
| from mercurial.node import ( | from mercurial.node import nullrev | ||||
| nullid, | |||||
| nullrev, | |||||
| ) | |||||
| from mercurial import ( | from mercurial import ( | ||||
| extensions, | extensions, | ||||
| requirements, | requirements, | ||||
| revlog, | revlog, | ||||
| ) | ) | ||||
| from mercurial.upgrade_utils import engine as upgrade_engine | from mercurial.upgrade_utils import engine as upgrade_engine | ||||
| def wrap_revisiondata(orig, self, nodeorrev, *args, **kwargs): | def wrap_revisiondata(orig, self, nodeorrev, *args, **kwargs): | ||||
| text, sd = orig(self, nodeorrev, *args, **kwargs) | text, sd = orig(self, nodeorrev, *args, **kwargs) | ||||
| if getattr(self, 'sidedatanocheck', False): | if getattr(self, 'sidedatanocheck', False): | ||||
| return text, sd | return text, sd | ||||
| if self.version & 0xFFFF != 2: | if self.version & 0xFFFF != 2: | ||||
| return text, sd | return text, sd | ||||
| if nodeorrev != nullrev and nodeorrev != nullid: | if nodeorrev != nullrev and nodeorrev != self.nullid: | ||||
| cat1 = sd.get(sidedata.SD_TEST1) | cat1 = sd.get(sidedata.SD_TEST1) | ||||
| if cat1 is not None and len(text) != struct.unpack('>I', cat1)[0]: | if cat1 is not None and len(text) != struct.unpack('>I', cat1)[0]: | ||||
| raise RuntimeError('text size mismatch') | raise RuntimeError('text size mismatch') | ||||
| expected = sd.get(sidedata.SD_TEST2) | expected = sd.get(sidedata.SD_TEST2) | ||||
| got = hashlib.sha256(text).digest() | got = hashlib.sha256(text).digest() | ||||
| if expected is not None and got != expected: | if expected is not None and got != expected: | ||||
| raise RuntimeError('sha256 mismatch') | raise RuntimeError('sha256 mismatch') | ||||
| return text, sd | return text, sd | ||||