| indygreg |
| hg-reviewers |
The code doing actual writing is already doing the necessary seeking, so we
could safely use 'r+'. This make the file objecs usable in more situation, like
updating the sidedata information during pull.
revlog: forcibly move the file cursor at the right location before writing
This is a paranoid change in case the changelog computation moved the cursors
under our feets.
This is not known to happens right now.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/revlog.py (20 lines) | |||
| M | mercurial/store.py (2 lines) |
| # manager | # 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) | nodemaputil.setup_persistent_nodemap(tr, self) | ||||
| self._chunkclear() | self._chunkclear() | ||||
| if existing_handles: | if existing_handles: | ||||
| # switched from inline to conventional reopen the index | # switched from inline to conventional reopen the index | ||||
| ifh = self._indexfp(b"a+") | ifh = self._indexfp(b"r+") | ||||
| self._writinghandles = (ifh, new_dfh) | self._writinghandles = (ifh, new_dfh) | ||||
| new_dfh = None | new_dfh = None | ||||
| finally: | finally: | ||||
| if new_dfh is not None: | if new_dfh is not None: | ||||
| new_dfh.close() | new_dfh.close() | ||||
| def _nodeduplicatecallback(self, transaction, node): | def _nodeduplicatecallback(self, transaction, node): | ||||
| """called when trying to add a node already stored.""" | """called when trying to add a node already stored.""" | ||||
| @contextlib.contextmanager | @contextlib.contextmanager | ||||
| def _writing(self, transaction): | def _writing(self, transaction): | ||||
| if self._writinghandles is not None: | if self._writinghandles is not None: | ||||
| yield | yield | ||||
| else: | else: | ||||
| r = len(self) | r = len(self) | ||||
| dsize = 0 | dsize = 0 | ||||
| if r: | if r: | ||||
| dsize = self.end(r - 1) | dsize = self.end(r - 1) | ||||
| dfh = None | dfh = None | ||||
| if not self._inline: | if not self._inline: | ||||
| dfh = self._datafp(b"a+") | try: | ||||
| dfh = self._datafp(b"r+") | |||||
| dfh.seek(0, os.SEEK_END) | |||||
| except IOError as inst: | |||||
| if inst.errno != errno.ENOENT: | |||||
| raise | |||||
| dfh = self._datafp(b"w+") | |||||
| transaction.add(self._datafile, dsize) | transaction.add(self._datafile, dsize) | ||||
| try: | try: | ||||
| isize = r * self.index.entry_size | isize = r * self.index.entry_size | ||||
| ifh = self._indexfp(b"a+") | try: | ||||
| ifh = self._indexfp(b"r+") | |||||
| ifh.seek(0, os.SEEK_END) | |||||
| except IOError as inst: | |||||
| if inst.errno != errno.ENOENT: | |||||
| raise | |||||
| ifh = self._indexfp(b"w+") | |||||
| if self._inline: | if self._inline: | ||||
| transaction.add(self._indexfile, dsize + isize) | transaction.add(self._indexfile, dsize + isize) | ||||
| else: | else: | ||||
| transaction.add(self._indexfile, isize) | transaction.add(self._indexfile, isize) | ||||
| try: | try: | ||||
| self._writinghandles = (ifh, dfh) | self._writinghandles = (ifh, dfh) | ||||
| try: | try: | ||||
| yield | yield | ||||
| raise error.Abort(msg) | raise error.Abort(msg) | ||||
| # Apply (potential) flags to add and to remove after running | # Apply (potential) flags to add and to remove after running | ||||
| # the sidedata helpers | # the sidedata helpers | ||||
| new_offset_flags = entry[0] | flags[0] & ~flags[1] | new_offset_flags = entry[0] | flags[0] & ~flags[1] | ||||
| entry = (new_offset_flags,) + entry[1:8] | entry = (new_offset_flags,) + entry[1:8] | ||||
| entry += (current_offset, len(serialized_sidedata)) | entry += (current_offset, len(serialized_sidedata)) | ||||
| # the sidedata computation might have move the file cursors around | |||||
| dfh.seek(current_offset, os.SEEK_SET) | |||||
| dfh.write(serialized_sidedata) | dfh.write(serialized_sidedata) | ||||
| new_entries.append(entry) | new_entries.append(entry) | ||||
| current_offset += len(serialized_sidedata) | current_offset += len(serialized_sidedata) | ||||
| # rewrite the new index entries | # rewrite the new index entries | ||||
| with self._indexfp(b'r+') as ifh: | with self._indexfp(b'r+') as ifh: | ||||
| fp.seek(startrev * self.index.entry_size) | fp.seek(startrev * self.index.entry_size) | ||||
| for i, e in enumerate(new_entries): | for i, e in enumerate(new_entries): | ||||
| rev = startrev + i | rev = startrev + i | ||||
| self.index.replace_sidedata_info(rev, e[8], e[9], e[0]) | self.index.replace_sidedata_info(rev, e[8], e[9], e[0]) | ||||
| packed = self.index.entry_binary(rev) | packed = self.index.entry_binary(rev) | ||||
| if rev == 0: | if rev == 0: | ||||
| header = self._format_flags | self._format_version | header = self._format_flags | self._format_version | ||||
| header = self.index.pack_header(header) | header = self.index.pack_header(header) | ||||
| packed = header + packed | packed = header + packed | ||||
| ifh.write(packed) | ifh.write(packed) | ||||
| def __call__(self, path, mode=b'r', *args, **kw): | def __call__(self, path, mode=b'r', *args, **kw): | ||||
| encoded = self.encode(path) | encoded = self.encode(path) | ||||
| if mode not in (b'r', b'rb') and ( | if mode not in (b'r', b'rb') and ( | ||||
| path.startswith(b'data/') or path.startswith(b'meta/') | path.startswith(b'data/') or path.startswith(b'meta/') | ||||
| ): | ): | ||||
| # do not trigger a fncache load when adding a file that already is | # do not trigger a fncache load when adding a file that already is | ||||
| # known to exist. | # known to exist. | ||||
| notload = self.fncache.entries is None and self.vfs.exists(encoded) | notload = self.fncache.entries is None and self.vfs.exists(encoded) | ||||
| if notload and b'a' in mode and not self.vfs.stat(encoded).st_size: | if notload and b'r+' in mode and not self.vfs.stat(encoded).st_size: | ||||
| # when appending to an existing file, if the file has size zero, | # when appending to an existing file, if the file has size zero, | ||||
| # it should be considered as missing. Such zero-size files are | # it should be considered as missing. Such zero-size files are | ||||
| # the result of truncation when a transaction is aborted. | # the result of truncation when a transaction is aborted. | ||||
| notload = False | notload = False | ||||
| if not notload: | if not notload: | ||||
| self.fncache.add(path) | self.fncache.add(path) | ||||
| return self.vfs(encoded, mode, *args, **kw) | return self.vfs(encoded, mode, *args, **kw) | ||||