mercurial-scm/hg-stable: mercurial/revlog.py comparison

comparison mercurial/revlog.py @ 47162:a07d5cb03a85

revlog: rename `indexfile` to `_indexfile` We want to make the actual location of the indexfile and location more of an implementation details than what is is currently. In that process, we make the attribute private. Differential Revision: https://phab.mercurial-scm.org/D10574

author	Pierre-Yves David <pierre-yves.david@octobus.net>
date	Mon, 03 May 2021 12:22:16 +0200
parents	c6b8d5d91e73
children	396442cd7e6a

comparison

equal deleted inserted replaced

-:8a1a51d31e85
+:a07d5cb03a85
 datafile = indexfile[:-2] + b".d"
 if postfix is not None:
 datafile = b'%s.%s' % (datafile, postfix)
 if postfix is not None:
 indexfile = b'%s.%s' % (indexfile, postfix)
-self.indexfile = indexfile
+self._indexfile = indexfile
 self.datafile = datafile
 self.nodemap_file = None
 self.postfix = postfix
 if persistentnodemap:
 self.nodemap_file = nodemaputil.get_nodemap_file(
-opener, self.indexfile
+opener, self._indexfile
 )
 self.opener = opener
 assert target[0] in ALL_KINDS
 assert len(target) == 2
 if fmt == REVLOGV0:
 if flags:
 raise error.RevlogError(
 _(b'unknown flags (%#04x) in version %d revlog %s')
-% (flags >> 16, fmt, self.indexfile)
+% (flags >> 16, fmt, self._indexfile)
 )
 self._inline = False
 self._generaldelta = False
 elif fmt == REVLOGV1:
 if flags & ~REVLOGV1_FLAGS:
 raise error.RevlogError(
 _(b'unknown flags (%#04x) in version %d revlog %s')
-% (flags >> 16, fmt, self.indexfile)
+% (flags >> 16, fmt, self._indexfile)
 )
 self._inline = versionflags & FLAG_INLINE_DATA
 self._generaldelta = versionflags & FLAG_GENERALDELTA
 elif fmt == REVLOGV2:
 if flags & ~REVLOGV2_FLAGS:
 raise error.RevlogError(
 _(b'unknown flags (%#04x) in version %d revlog %s')
-% (flags >> 16, fmt, self.indexfile)
+% (flags >> 16, fmt, self._indexfile)
 )
 # There is a bug in the transaction handling when going from an
 # inline revlog to a separate index and data file. Turn it off until
 # it's fixed, since v2 revlogs sometimes get rewritten on exchange.
 # generaldelta implied by version 2 revlogs.
 self._generaldelta = True
 else:
 raise error.RevlogError(
-_(b'unknown version (%d) in revlog %s') % (fmt, self.indexfile)
+_(b'unknown version (%d) in revlog %s') % (fmt, self._indexfile)
 )
 self.nodeconstants = sha1nodeconstants
 self.nullid = self.nodeconstants.nullid
 # no changelog tampering
 self._nodemap_docket = docket
 index.update_nodemap_data(*nodemap_data)
 except (ValueError, IndexError):
 raise error.RevlogError(
-_(b"index %s is corrupted") % self.indexfile
+_(b"index %s is corrupted") % self._indexfile
 )
 self.index, self._chunkcache = d
 if not self._chunkcache:
 self._chunkclear()
 # revnum -> (chain-length, sum-delta-length)
 args = {'mode': mode}
 if mode != b'r':
 args['checkambig'] = self._checkambig
 if mode == b'w':
 args['atomictemp'] = True
-return self.opener(self.indexfile, **args)
+return self.opener(self._indexfile, **args)
 def _datafp(self, mode=b'r'):
 """file object for the revlog's data file"""
 return self.opener(self.datafile, mode=mode)
 if (
 node == self.nodeconstants.wdirid
 or node in self.nodeconstants.wdirfilenodeids
 ):
 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.
 # First tuple entry is 8 bytes. First 6 bytes are offset. Last 2 bytes
 # are flags.
 except error.RevlogError:
 # parsers.c radix tree lookup gave multiple matches
 # fast path: for unfiltered changelog, radix tree is accurate
 if not getattr(self, 'filteredrevs', None):
 raise error.AmbiguousPrefixLookupError(
-id, self.indexfile, _(b'ambiguous identifier')
+id, self._indexfile, _(b'ambiguous identifier')
 )
 # fall through to slow path that filters hidden revisions
 except (AttributeError, ValueError):
 # we are pure python, or key was too short to search radix tree
 pass
 if len(nl) > 0:
 if len(nl) == 1 and not maybewdir:
 self._pcache[id] = nl[0]
 return nl[0]
 raise error.AmbiguousPrefixLookupError(
-id, self.indexfile, _(b'ambiguous identifier')
+id, self._indexfile, _(b'ambiguous identifier')
 )
 if maybewdir:
 raise error.WdirUnsupported
 return None
 except TypeError:
 return n
 n = self._partialmatch(id)
 if n:
 return n
-raise error.LookupError(id, self.indexfile, _(b'no match found'))
+raise error.LookupError(id, self._indexfile, _(b'no match found'))
 def shortest(self, node, minlength=1):
 """Find the shortest unambiguous prefix that matches node."""
 def isvalid(prefix):
 return False
 except error.WdirUnsupported:
 # single 'ff...' match
 return True
 if matchednode is None:
-raise error.LookupError(node, self.indexfile, _(b'no node'))
+raise error.LookupError(node, self._indexfile, _(b'no node'))
 return True
 def maybewdir(prefix):
 return all(c == b'f' for c in pycompat.iterbytestr(prefix))
 try:
 length = max(self.index.shortest(node), minlength)
 return disambiguate(hexnode, length)
 except error.RevlogError:
 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:
 # Fall through to pure code
 pass
 if node == self.nodeconstants.wdirid:
 _(
 b'partial read of revlog %s; expected %d bytes from '
 b'offset %d, got %d'
 )
 % (
-self.indexfile if self._inline else self.datafile,
+self._indexfile if self._inline else self.datafile,
 length,
 realoffset,
 len(d) - startoffset,
 )
 )
 _(
 b'partial read of revlog %s; expected %d bytes from offset '
 b'%d, got %d'
 )
 % (
-self.indexfile if self._inline else self.datafile,
+self._indexfile if self._inline else self.datafile,
 length,
 offset,
 len(d),
 )
 )
 revornode = rev
 if revornode is None:
 revornode = templatefilters.short(hex(node))
 raise error.RevlogError(
 _(b"integrity check failed on %s:%s")
-% (self.indexfile, pycompat.bytestr(revornode))
+% (self._indexfile, pycompat.bytestr(revornode))
 )
 except error.RevlogError:
 if self._censorable and storageutil.iscensoredtext(text):
-raise error.CensoredNodeError(self.indexfile, node, text)
+raise error.CensoredNodeError(self._indexfile, node, text)
 raise
 def _enforceinlinesize(self, tr, fp=None):
 """Check if the revlog is too big for inline and convert if so.
 not self._inline
 or (self.start(tiprev) + self.length(tiprev)) < _maxinline
 ):
 return
-troffset = tr.findoffset(self.indexfile)
+troffset = tr.findoffset(self._indexfile)
 if troffset is None:
 raise error.RevlogError(
-_(b"%s not found in the transaction") % self.indexfile
+_(b"%s not found in the transaction") % self._indexfile
 )
 trindex = 0
 tr.add(self.datafile, 0)
 if fp:
 fp.write(e)
 # the temp file replace the real index when we exit the context
 # manager
-tr.replace(self.indexfile, trindex * self.index.entry_size)
+tr.replace(self._indexfile, trindex * self.index.entry_size)
 nodemaputil.setup_persistent_nodemap(tr, self)
 self._chunkclear()
 def _nodeduplicatecallback(self, transaction, node):
 """called when trying to add a node already stored."""
 deltacomputer - an optional deltacomputer instance shared between
 multiple calls
 """
 if link == nullrev:
 raise error.RevlogError(
-_(b"attempted to add linkrev -1 to %s") % self.indexfile
+_(b"attempted to add linkrev -1 to %s") % self._indexfile
 )
 if sidedata is None:
 sidedata = {}
 elif sidedata and not self.hassidedata:
 if len(rawtext) > _maxentrysize:
 raise error.RevlogError(
 _(
 b"%s: size of %d bytes exceeds maximum revlog storage of 2GiB"
 )
-% (self.indexfile, len(rawtext))
+% (self._indexfile, len(rawtext))
 )
 node = node or self.hash(rawtext, p1, p2)
 rev = self.index.get_rev(node)
 if rev is not None:
 - rawtext is optional (can be None); if not set, cachedelta must be set.
 if both are set, they must correspond to each other.
 """
 if node == self.nullid:
 raise error.RevlogError(
-_(b"%s: attempt to add null revision") % self.indexfile
+_(b"%s: attempt to add null revision") % self._indexfile
 )
 if (
 node == self.nodeconstants.wdirid
 or node in self.nodeconstants.wdirfilenodeids
 ):
 raise error.RevlogError(
-_(b"%s: attempt to add wdir revision") % self.indexfile
+_(b"%s: attempt to add wdir revision") % self._indexfile
 )
 if self._inline:
 fh = ifh
 else:
 if self._concurrencychecker:
 if self._inline:
 # offset is "as if" it were in the .d file, so we need to add on
 # the size of the entry metadata.
 self._concurrencychecker(
-ifh, self.indexfile, offset + curr * self.index.entry_size
+ifh, self._indexfile, offset + curr * self.index.entry_size
 )
 else:
 # Entries in the .i are a consistent size.
 self._concurrencychecker(
-ifh, self.indexfile, curr * self.index.entry_size
+ifh, self._indexfile, curr * self.index.entry_size
 )
 self._concurrencychecker(dfh, self.datafile, offset)
 p1r, p2r = self.rev(p1), self.rev(p2)
 dfh.seek(0, os.SEEK_END)
 curr = len(self) - 1
 if not self._inline:
 transaction.add(self.datafile, offset)
-transaction.add(self.indexfile, curr * len(entry))
+transaction.add(self._indexfile, curr * len(entry))
 if data[0]:
 dfh.write(data[0])
 dfh.write(data[1])
 if sidedata:
 dfh.write(sidedata)
 ifh.write(entry)
 else:
 offset += curr * self.index.entry_size
-transaction.add(self.indexfile, offset)
+transaction.add(self._indexfile, offset)
 ifh.write(entry)
 ifh.write(data[0])
 ifh.write(data[1])
 if sidedata:
 ifh.write(sidedata)
 if r:
 end = self.end(r - 1)
 ifh = self._indexfp(b"a+")
 isize = r * self.index.entry_size
 if self._inline:
-transaction.add(self.indexfile, end + isize)
+transaction.add(self._indexfile, end + isize)
 dfh = None
 else:
-transaction.add(self.indexfile, isize)
+transaction.add(self._indexfile, isize)
 transaction.add(self.datafile, end)
 dfh = self._datafp(b"a+")
 def flush():
 if dfh:
 continue
 for p in (p1, p2):
 if not self.index.has_node(p):
 raise error.LookupError(
-p, self.indexfile, _(b'unknown parent')
+p, self._indexfile, _(b'unknown parent')
 )
 if not self.index.has_node(deltabase):
 raise error.LookupError(
-deltabase, self.indexfile, _(b'unknown delta base')
+deltabase, self._indexfile, _(b'unknown delta base')
 )
 baserev = self.rev(deltabase)
 if baserev != nullrev and self.iscensored(baserev):
 hlen = struct.calcsize(b">lll")
 oldlen = self.rawsize(baserev)
 newlen = len(delta) - hlen
 if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen):
 raise error.CensoredBaseError(
-self.indexfile, self.node(baserev)
+self._indexfile, self.node(baserev)
 )
 if not flags and self._peek_iscensored(baserev, delta, flush):
 flags |= REVIDX_ISCENSORED
 transaction.add(self.datafile, end)
 end = rev * self.index.entry_size
 else:
 end += rev * self.index.entry_size
-transaction.add(self.indexfile, end)
+transaction.add(self._indexfile, end)
 # then reset internal state in memory to forget those revisions
 self._revisioncache = None
 self._chaininfocache = util.lrucachedict(500)
 self._chunkclear()
 if inst.errno != errno.ENOENT:
 raise
 dd = 0
 try:
-f = self.opener(self.indexfile)
+f = self.opener(self._indexfile)
 f.seek(0, io.SEEK_END)
 actual = f.tell()
 f.close()
 s = self.index.entry_size
 i = max(0, actual // s)
 di = 0
 return (dd, di)
 def files(self):
-res = [self.indexfile]
+res = [self._indexfile]
 if not self._inline:
 res.append(self.datafile)
 return res
 def emitrevisions(
 self, sidedata_helpers, sidedata, rev
 )
 flags = flags | new_flags[0] & ~new_flags[1]
 ifh = destrevlog.opener(
-destrevlog.indexfile, b'a+', checkambig=False
+destrevlog._indexfile, b'a+', checkambig=False
 )
 dfh = None
 if not destrevlog._inline:
 dfh = destrevlog.opener(destrevlog.datafile, b'a+')
 try:
 # This is a bit dangerous. We could easily have a mismatch of state.
 newrl = revlog(
 self.opener,
 target=self.target,
 postfix=b'tmpcensored',
-indexfile=self.indexfile,
+indexfile=self._indexfile,
 censorable=True,
 )
 newrl._format_version = self._format_version
 newrl._format_flags = self._format_flags
 newrl._generaldelta = self._generaldelta
 newrl.addrawrevision(
 rawtext, tr, self.linkrev(rev), p1, p2, node, self.flags(rev)
 )
-tr.addbackup(self.indexfile, location=b'store')
+tr.addbackup(self._indexfile, location=b'store')
 if not self._inline:
 tr.addbackup(self.datafile, location=b'store')
-self.opener.rename(newrl.indexfile, self.indexfile)
+self.opener.rename(newrl._indexfile, self._indexfile)
 if not self._inline:
 self.opener.rename(newrl.datafile, self.datafile)
 self.clearcaches()
 self._loadindex()
 # The verifier tells us what version revlog we should be.
 if version != state[b'expectedversion']:
 yield revlogproblem(
 warning=_(b"warning: '%s' uses revlog format %d; expected %d")
-% (self.indexfile, version, state[b'expectedversion'])
+% (self._indexfile, version, state[b'expectedversion'])
 )
 state[b'skipread'] = set()
 state[b'safe_renamed'] = set()
 storedsize=False,
 ):
 d = {}
 if exclusivefiles:
-d[b'exclusivefiles'] = [(self.opener, self.indexfile)]
+d[b'exclusivefiles'] = [(self.opener, self._indexfile)]
 if not self._inline:
 d[b'exclusivefiles'].append((self.opener, self.datafile))
 if sharedfiles:
 d[b'sharedfiles'] = []

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/revlog.py @ 47162:a07d5cb03a85