mercurial: comparison mercurial/revlog.py

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'] = []

changeset 47148	a07d5cb03a85
parent 47145	c6b8d5d91e73
child 47149	396442cd7e6a