dirstate: deal with read-race for pure python code

If we cannot read the dirstate data, this is probably because a writing process
wrote it under our feet. So refresh the docket and try again a handful of time.

mercurial/dirstatemap.py

@@ -1,715 +1,733 b''
 # dirstatemap.py
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 from .i18n import _
 
 from . import (
     error,
     pathutil,
     policy,
     testing,
     txnutil,
     util,
 )
 
 from .dirstateutils import (
     docket as docketmod,
     v2,
 )
 
 parsers = policy.importmod('parsers')
 rustmod = policy.importrust('dirstate')
 
 propertycache = util.propertycache
 
 if rustmod is None:
     DirstateItem = parsers.DirstateItem
 else:
     DirstateItem = rustmod.DirstateItem
 
 rangemask = 0x7FFFFFFF
 
 WRITE_MODE_AUTO = 0
 WRITE_MODE_FORCE_NEW = 1
 WRITE_MODE_FORCE_APPEND = 2
 
 
+V2_MAX_READ_ATTEMPTS = 5
+
+
 class _dirstatemapcommon:
     """
     Methods that are identical for both implementations of the dirstatemap
     class, with and without Rust extensions enabled.
     """
 
     # please pytype
 
     _map = None
     copymap = None
 
     def __init__(self, ui, opener, root, nodeconstants, use_dirstate_v2):
         self._use_dirstate_v2 = use_dirstate_v2
         self._nodeconstants = nodeconstants
         self._ui = ui
         self._opener = opener
         self._root = root
         self._filename = b'dirstate'
         self._nodelen = 20  # Also update Rust code when changing this!
         self._parents = None
         self._dirtyparents = False
         self._docket = None
         write_mode = ui.config(b"devel", b"dirstate.v2.data_update_mode")
         if write_mode == b"auto":
             self._write_mode = WRITE_MODE_AUTO
         elif write_mode == b"force-append":
             self._write_mode = WRITE_MODE_FORCE_APPEND
         elif write_mode == b"force-new":
             self._write_mode = WRITE_MODE_FORCE_NEW
         else:
             # unknown value, fallback to default
             self._write_mode = WRITE_MODE_AUTO
 
         # for consistent view between _pl() and _read() invocations
         self._pendingmode = None
 
     def preload(self):
         """Loads the underlying data, if it's not already loaded"""
         self._map
 
     def get(self, key, default=None):
         return self._map.get(key, default)
 
     def __len__(self):
         return len(self._map)
 
     def __iter__(self):
         return iter(self._map)
 
     def __contains__(self, key):
         return key in self._map
 
     def __getitem__(self, item):
         return self._map[item]
 
     ### disk interaction
 
     def _opendirstatefile(self):
         fp, mode = txnutil.trypending(self._root, self._opener, self._filename)
         if self._pendingmode is not None and self._pendingmode != mode:
             fp.close()
             raise error.Abort(
                 _(b'working directory state may be changed parallelly')
             )
         self._pendingmode = mode
         return fp
 
     def _readdirstatefile(self, size=-1):
         try:
             with self._opendirstatefile() as fp:
                 return fp.read(size)
         except FileNotFoundError:
             # File doesn't exist, so the current state is empty
             return b''
 
     @property
     def docket(self):
         if not self._docket:
             if not self._use_dirstate_v2:
                 raise error.ProgrammingError(
                     b'dirstate only has a docket in v2 format'
                 )
             self._docket = docketmod.DirstateDocket.parse(
                 self._readdirstatefile(), self._nodeconstants
             )
         return self._docket
 
     def _read_v2_data(self):
+        data = None
+        attempts = 0
+        while attempts < V2_MAX_READ_ATTEMPTS:
+            attempts += 1
+            try:
+                data = self._opener.read(self.docket.data_filename())
+            except FileNotFoundError:
+                # read race detected between docket and data file
+                # reload the docket and retry
+                self._docket = None
+        if data is None:
+            assert attempts >= V2_MAX_READ_ATTEMPTS
+            msg = b"dirstate read race happened %d times in a row"
+            msg %= attempts
+            raise error.Abort(msg)
         return self._opener.read(self.docket.data_filename())
 
     def write_v2_no_append(self, tr, st, meta, packed):
         old_docket = self.docket
         new_docket = docketmod.DirstateDocket.with_new_uuid(
             self.parents(), len(packed), meta
         )
         if old_docket.uuid == new_docket.uuid:
             raise error.ProgrammingError(b'dirstate docket name collision')
         data_filename = new_docket.data_filename()
         self._opener.write(data_filename, packed)
         # Write the new docket after the new data file has been
         # written. Because `st` was opened with `atomictemp=True`,
         # the actual `.hg/dirstate` file is only affected on close.
         st.write(new_docket.serialize())
         st.close()
         # Remove the old data file after the new docket pointing to
         # the new data file was written.
         if old_docket.uuid:
             data_filename = old_docket.data_filename()
             unlink = lambda _tr=None: self._opener.unlink(data_filename)
             if tr:
                 category = b"dirstate-v2-clean-" + old_docket.uuid
                 tr.addpostclose(category, unlink)
             else:
                 unlink()
         self._docket = new_docket
 
     ### reading/setting parents
 
     def parents(self):
         if not self._parents:
             if self._use_dirstate_v2:
                 self._parents = self.docket.parents
             else:
                 read_len = self._nodelen * 2
                 st = self._readdirstatefile(read_len)
                 l = len(st)
                 if l == read_len:
                     self._parents = (
                         st[: self._nodelen],
                         st[self._nodelen : 2 * self._nodelen],
                     )
                 elif l == 0:
                     self._parents = (
                         self._nodeconstants.nullid,
                         self._nodeconstants.nullid,
                     )
                 else:
                     raise error.Abort(
                         _(b'working directory state appears damaged!')
                     )
 
         return self._parents
 
 
 class dirstatemap(_dirstatemapcommon):
     """Map encapsulating the dirstate's contents.
 
     The dirstate contains the following state:
 
     - `identity` is the identity of the dirstate file, which can be used to
       detect when changes have occurred to the dirstate file.
 
     - `parents` is a pair containing the parents of the working copy. The
       parents are updated by calling `setparents`.
 
     - the state map maps filenames to tuples of (state, mode, size, mtime),
       where state is a single character representing 'normal', 'added',
       'removed', or 'merged'. It is read by treating the dirstate as a
       dict.  File state is updated by calling various methods (see each
       documentation for details):
 
       - `reset_state`,
       - `set_tracked`
       - `set_untracked`
       - `set_clean`
       - `set_possibly_dirty`
 
     - `copymap` maps destination filenames to their source filename.
 
     The dirstate also provides the following views onto the state:
 
     - `filefoldmap` is a dict mapping normalized filenames to the denormalized
       form that they appear as in the dirstate.
 
     - `dirfoldmap` is a dict mapping normalized directory names to the
       denormalized form that they appear as in the dirstate.
     """
 
     ### Core data storage and access
 
     @propertycache
     def _map(self):
         self._map = {}
         self.read()
         return self._map
 
     @propertycache
     def copymap(self):
         self.copymap = {}
         self._map
         return self.copymap
 
     def clear(self):
         self._map.clear()
         self.copymap.clear()
         self.setparents(self._nodeconstants.nullid, self._nodeconstants.nullid)
         util.clearcachedproperty(self, b"_dirs")
         util.clearcachedproperty(self, b"_alldirs")
         util.clearcachedproperty(self, b"filefoldmap")
         util.clearcachedproperty(self, b"dirfoldmap")
 
     def items(self):
         return self._map.items()
 
     # forward for python2,3 compat
     iteritems = items
 
     def debug_iter(self, all):
         """
         Return an iterator of (filename, state, mode, size, mtime) tuples
 
         `all` is unused when Rust is not enabled
         """
         for (filename, item) in self.items():
             yield (filename, item.state, item.mode, item.size, item.mtime)
 
     def keys(self):
         return self._map.keys()
 
     ### reading/setting parents
 
     def setparents(self, p1, p2, fold_p2=False):
         self._parents = (p1, p2)
         self._dirtyparents = True
         copies = {}
         if fold_p2:
             for f, s in self._map.items():
                 # Discard "merged" markers when moving away from a merge state
                 if s.p2_info:
                     source = self.copymap.pop(f, None)
                     if source:
                         copies[f] = source
                     s.drop_merge_data()
         return copies
 
     ### disk interaction
 
     def read(self):
         # ignore HG_PENDING because identity is used only for writing
         self.identity = util.filestat.frompath(
             self._opener.join(self._filename)
         )
 
         testing.wait_on_cfg(self._ui, b'dirstate.pre-read-file')
         if self._use_dirstate_v2:
 
             if not self.docket.uuid:
                 return
             testing.wait_on_cfg(self._ui, b'dirstate.post-docket-read-file')
             st = self._read_v2_data()
         else:
             st = self._readdirstatefile()
 
         if not st:
             return
 
         # TODO: adjust this estimate for dirstate-v2
         if util.safehasattr(parsers, b'dict_new_presized'):
             # Make an estimate of the number of files in the dirstate based on
             # its size. This trades wasting some memory for avoiding costly
             # resizes. Each entry have a prefix of 17 bytes followed by one or
             # two path names. Studies on various large-scale real-world repositories
             # found 54 bytes a reasonable upper limit for the average path names.
             # Copy entries are ignored for the sake of this estimate.
             self._map = parsers.dict_new_presized(len(st) // 71)
 
         # Python's garbage collector triggers a GC each time a certain number
         # of container objects (the number being defined by
         # gc.get_threshold()) are allocated. parse_dirstate creates a tuple
         # for each file in the dirstate. The C version then immediately marks
         # them as not to be tracked by the collector. However, this has no
         # effect on when GCs are triggered, only on what objects the GC looks
         # into. This means that O(number of files) GCs are unavoidable.
         # Depending on when in the process's lifetime the dirstate is parsed,
         # this can get very expensive. As a workaround, disable GC while
         # parsing the dirstate.
         #
         # (we cannot decorate the function directly since it is in a C module)
         if self._use_dirstate_v2:
             p = self.docket.parents
             meta = self.docket.tree_metadata
             parse_dirstate = util.nogc(v2.parse_dirstate)
             parse_dirstate(self._map, self.copymap, st, meta)
         else:
             parse_dirstate = util.nogc(parsers.parse_dirstate)
             p = parse_dirstate(self._map, self.copymap, st)
         if not self._dirtyparents:
             self.setparents(*p)
 
         # Avoid excess attribute lookups by fast pathing certain checks
         self.__contains__ = self._map.__contains__
         self.__getitem__ = self._map.__getitem__
         self.get = self._map.get
 
     def write(self, tr, st):
         if self._use_dirstate_v2:
             packed, meta = v2.pack_dirstate(self._map, self.copymap)
             self.write_v2_no_append(tr, st, meta, packed)
         else:
             packed = parsers.pack_dirstate(
                 self._map, self.copymap, self.parents()
             )
             st.write(packed)
             st.close()
         self._dirtyparents = False
 
     @propertycache
     def identity(self):
         self._map
         return self.identity
 
     ### code related to maintaining and accessing "extra" property
     # (e.g. "has_dir")
 
     def _dirs_incr(self, filename, old_entry=None):
         """increment the dirstate counter if applicable"""
         if (
             old_entry is None or old_entry.removed
         ) and "_dirs" in self.__dict__:
             self._dirs.addpath(filename)
         if old_entry is None and "_alldirs" in self.__dict__:
             self._alldirs.addpath(filename)
 
     def _dirs_decr(self, filename, old_entry=None, remove_variant=False):
         """decrement the dirstate counter if applicable"""
         if old_entry is not None:
             if "_dirs" in self.__dict__ and not old_entry.removed:
                 self._dirs.delpath(filename)
             if "_alldirs" in self.__dict__ and not remove_variant:
                 self._alldirs.delpath(filename)
         elif remove_variant and "_alldirs" in self.__dict__:
             self._alldirs.addpath(filename)
         if "filefoldmap" in self.__dict__:
             normed = util.normcase(filename)
             self.filefoldmap.pop(normed, None)
 
     @propertycache
     def filefoldmap(self):
         """Returns a dictionary mapping normalized case paths to their
         non-normalized versions.
         """
         try:
             makefilefoldmap = parsers.make_file_foldmap
         except AttributeError:
             pass
         else:
             return makefilefoldmap(
                 self._map, util.normcasespec, util.normcasefallback
             )
 
         f = {}
         normcase = util.normcase
         for name, s in self._map.items():
             if not s.removed:
                 f[normcase(name)] = name
         f[b'.'] = b'.'  # prevents useless util.fspath() invocation
         return f
 
     @propertycache
     def dirfoldmap(self):
         f = {}
         normcase = util.normcase
         for name in self._dirs:
             f[normcase(name)] = name
         return f
 
     def hastrackeddir(self, d):
         """
         Returns True if the dirstate contains a tracked (not removed) file
         in this directory.
         """
         return d in self._dirs
 
     def hasdir(self, d):
         """
         Returns True if the dirstate contains a file (tracked or removed)
         in this directory.
         """
         return d in self._alldirs
 
     @propertycache
     def _dirs(self):
         return pathutil.dirs(self._map, only_tracked=True)
 
     @propertycache
     def _alldirs(self):
         return pathutil.dirs(self._map)
 
     ### code related to manipulation of entries and copy-sources
 
     def reset_state(
         self,
         filename,
         wc_tracked=False,
         p1_tracked=False,
         p2_info=False,
         has_meaningful_mtime=True,
         parentfiledata=None,
     ):
         """Set a entry to a given state, diregarding all previous state
 
         This is to be used by the part of the dirstate API dedicated to
         adjusting the dirstate after a update/merge.
 
         note: calling this might result to no entry existing at all if the
         dirstate map does not see any point at having one for this file
         anymore.
         """
         # copy information are now outdated
         # (maybe new information should be in directly passed to this function)
         self.copymap.pop(filename, None)
 
         if not (p1_tracked or p2_info or wc_tracked):
             old_entry = self._map.get(filename)
             self._drop_entry(filename)
             self._dirs_decr(filename, old_entry=old_entry)
             return
 
         old_entry = self._map.get(filename)
         self._dirs_incr(filename, old_entry)
         entry = DirstateItem(
             wc_tracked=wc_tracked,
             p1_tracked=p1_tracked,
             p2_info=p2_info,
             has_meaningful_mtime=has_meaningful_mtime,
             parentfiledata=parentfiledata,
         )
         self._map[filename] = entry
 
     def set_tracked(self, filename):
         new = False
         entry = self.get(filename)
         if entry is None:
             self._dirs_incr(filename)
             entry = DirstateItem(
                 wc_tracked=True,
             )
 
             self._map[filename] = entry
             new = True
         elif not entry.tracked:
             self._dirs_incr(filename, entry)
             entry.set_tracked()
             self._refresh_entry(filename, entry)
             new = True
         else:
             # XXX This is probably overkill for more case, but we need this to
             # fully replace the `normallookup` call with `set_tracked` one.
             # Consider smoothing this in the future.
             entry.set_possibly_dirty()
             self._refresh_entry(filename, entry)
         return new
 
     def set_untracked(self, f):
         """Mark a file as no longer tracked in the dirstate map"""
         entry = self.get(f)
         if entry is None:
             return False
         else:
             self._dirs_decr(f, old_entry=entry, remove_variant=not entry.added)
             if not entry.p2_info:
                 self.copymap.pop(f, None)
             entry.set_untracked()
             self._refresh_entry(f, entry)
             return True
 
     def set_clean(self, filename, mode, size, mtime):
         """mark a file as back to a clean state"""
         entry = self[filename]
         size = size & rangemask
         entry.set_clean(mode, size, mtime)
         self._refresh_entry(filename, entry)
         self.copymap.pop(filename, None)
 
     def set_possibly_dirty(self, filename):
         """record that the current state of the file on disk is unknown"""
         entry = self[filename]
         entry.set_possibly_dirty()
         self._refresh_entry(filename, entry)
 
     def _refresh_entry(self, f, entry):
         """record updated state of an entry"""
         if not entry.any_tracked:
             self._map.pop(f, None)
 
     def _drop_entry(self, f):
         """remove any entry for file f
 
         This should also drop associated copy information
 
         The fact we actually need to drop it is the responsability of the caller"""
         self._map.pop(f, None)
         self.copymap.pop(f, None)
 
 
 if rustmod is not None:
 
     class dirstatemap(_dirstatemapcommon):
 
         ### Core data storage and access
 
         @propertycache
         def _map(self):
             """
             Fills the Dirstatemap when called.
             """
             # ignore HG_PENDING because identity is used only for writing
             self.identity = util.filestat.frompath(
                 self._opener.join(self._filename)
             )
 
             testing.wait_on_cfg(self._ui, b'dirstate.pre-read-file')
             if self._use_dirstate_v2:
                 if self.docket.uuid:
                     testing.wait_on_cfg(
                         self._ui, b'dirstate.post-docket-read-file'
                     )
                     # TODO: use mmap when possible
                     data = self._opener.read(self.docket.data_filename())
                 else:
                     data = b''
                 self._map = rustmod.DirstateMap.new_v2(
                     data, self.docket.data_size, self.docket.tree_metadata
                 )
                 parents = self.docket.parents
             else:
                 self._map, parents = rustmod.DirstateMap.new_v1(
                     self._readdirstatefile()
                 )
 
             if parents and not self._dirtyparents:
                 self.setparents(*parents)
 
             self.__contains__ = self._map.__contains__
             self.__getitem__ = self._map.__getitem__
             self.get = self._map.get
             return self._map
 
         @property
         def copymap(self):
             return self._map.copymap()
 
         def debug_iter(self, all):
             """
             Return an iterator of (filename, state, mode, size, mtime) tuples
 
             `all`: also include with `state == b' '` dirstate tree nodes that
             don't have an associated `DirstateItem`.
 
             """
             return self._map.debug_iter(all)
 
         def clear(self):
             self._map.clear()
             self.setparents(
                 self._nodeconstants.nullid, self._nodeconstants.nullid
             )
             util.clearcachedproperty(self, b"_dirs")
             util.clearcachedproperty(self, b"_alldirs")
             util.clearcachedproperty(self, b"dirfoldmap")
 
         def items(self):
             return self._map.items()
 
         # forward for python2,3 compat
         iteritems = items
 
         def keys(self):
             return iter(self._map)
 
         ### reading/setting parents
 
         def setparents(self, p1, p2, fold_p2=False):
             self._parents = (p1, p2)
             self._dirtyparents = True
             copies = {}
             if fold_p2:
                 copies = self._map.setparents_fixup()
             return copies
 
         ### disk interaction
 
         @propertycache
         def identity(self):
             self._map
             return self.identity
 
         def write(self, tr, st):
             if not self._use_dirstate_v2:
                 p1, p2 = self.parents()
                 packed = self._map.write_v1(p1, p2)
                 st.write(packed)
                 st.close()
                 self._dirtyparents = False
                 return
 
             # We can only append to an existing data file if there is one
             write_mode = self._write_mode
             if self.docket.uuid is None:
                 write_mode = WRITE_MODE_FORCE_NEW
             packed, meta, append = self._map.write_v2(write_mode)
             if append:
                 docket = self.docket
                 data_filename = docket.data_filename()
                 with self._opener(data_filename, b'r+b') as fp:
                     fp.seek(docket.data_size)
                     assert fp.tell() == docket.data_size
                     written = fp.write(packed)
                     if written is not None:  # py2 may return None
                         assert written == len(packed), (written, len(packed))
                 docket.data_size += len(packed)
                 docket.parents = self.parents()
                 docket.tree_metadata = meta
                 st.write(docket.serialize())
                 st.close()
             else:
                 self.write_v2_no_append(tr, st, meta, packed)
             # Reload from the newly-written file
             util.clearcachedproperty(self, b"_map")
             self._dirtyparents = False
 
         ### code related to maintaining and accessing "extra" property
         # (e.g. "has_dir")
 
         @propertycache
         def filefoldmap(self):
             """Returns a dictionary mapping normalized case paths to their
             non-normalized versions.
             """
             return self._map.filefoldmapasdict()
 
         def hastrackeddir(self, d):
             return self._map.hastrackeddir(d)
 
         def hasdir(self, d):
             return self._map.hasdir(d)
 
         @propertycache
         def dirfoldmap(self):
             f = {}
             normcase = util.normcase
             for name in self._map.tracked_dirs():
                 f[normcase(name)] = name
             return f
 
         ### code related to manipulation of entries and copy-sources
 
         def set_tracked(self, f):
             return self._map.set_tracked(f)
 
         def set_untracked(self, f):
             return self._map.set_untracked(f)
 
         def set_clean(self, filename, mode, size, mtime):
             self._map.set_clean(filename, mode, size, mtime)
 
         def set_possibly_dirty(self, f):
             self._map.set_possibly_dirty(f)
 
         def reset_state(
             self,
             filename,
             wc_tracked=False,
             p1_tracked=False,
             p2_info=False,
             has_meaningful_mtime=True,
             parentfiledata=None,
         ):
             return self._map.reset_state(
                 filename,
                 wc_tracked,
                 p1_tracked,
                 p2_info,
                 has_meaningful_mtime,
                 parentfiledata,
             )

tests/test-dirstate-read-race.t

@@ -1,554 +1,569 b''
 ==============================================================================
 Check potential race conditions between a dirstate's read and other operations
 ==============================================================================
 
 #testcases dirstate-v1 dirstate-v2-append dirstate-v2-rewrite
 #testcases pre-all-read pre-some-read
 
 Some commands, like `hg status`, do not need to take the wlock but need to
 access dirstate data.
 Other commands might update the dirstate data while this happens.
 
 This can create issues if repository data is read in the wrong order, or for
 the dirstate-v2 format where the data is contained in multiple files.
 
 This test file is meant to test various cases where such parallel operations
 happen and make sure the reading process behaves fine. We do so with a `hg
 status` command since it is probably the most advanced of such read-only
 command.
 
 It bears simililarity with `tests/test-dirstate-status-race.t ` but tests a
 different type of race.
 
 Setup
 =====
 
   $ cat >> $HGRCPATH << EOF
   > [storage]
   > dirstate-v2.slow-path=allow
   > EOF
 
 #if no-dirstate-v1
   $ cat >> $HGRCPATH << EOF
   > [format]
   > use-dirstate-v2=yes
   > EOF
 #else
   $ cat >> $HGRCPATH << EOF
   > [format]
   > use-dirstate-v2=no
   > EOF
 #endif
 
 #if dirstate-v2-rewrite
   $ d2args="--config devel.dirstate.v2.data_update_mode=force-new"
 #endif
 #if dirstate-v2-append
   $ d2args="--config devel.dirstate.v2.data_update_mode=force-append"
 #endif
 
 
 #if dirstate-v1
   $ cfg="devel.sync.dirstate.pre-read-file"
 #else
 #if pre-all-read
   $ cfg="devel.sync.dirstate.pre-read-file"
 #else
   $ cfg="devel.sync.dirstate.post-docket-read-file"
 #endif
 #endif
 
   $ directories="dir dir/nested dir2"
   $ first_files="dir/nested/a dir/b dir/c dir/d dir2/e f"
   $ second_files="g dir/nested/h dir/i dir/j dir2/k dir2/l dir/nested/m"
   $ extra_files="dir/n dir/o p q"
 
   $ hg init reference-repo
   $ cd reference-repo
   $ mkdir -p dir/nested dir2
   $ touch -t 200001010000 $first_files $directories
   $ hg commit -Aqm "recreate a bunch of files to facilitate dirstate-v2 append"
   $ touch -t 200001010010 $second_files $directories
   $ hg commit -Aqm "more files to have two commit"
   $ hg log -G -v
   @  changeset:   1:9a86dcbfb938
   |  tag:         tip
   |  user:        test
   |  date:        Thu Jan 01 00:00:00 1970 +0000
   |  files:       dir/i dir/j dir/nested/h dir/nested/m dir2/k dir2/l g
   |  description:
   |  more files to have two commit
   |
   |
   o  changeset:   0:4f23db756b09
      user:        test
      date:        Thu Jan 01 00:00:00 1970 +0000
      files:       dir/b dir/c dir/d dir/nested/a dir2/e f
      description:
      recreate a bunch of files to facilitate dirstate-v2 append
   
   
   $ hg manifest
   dir/b
   dir/c
   dir/d
   dir/i
   dir/j
   dir/nested/a
   dir/nested/h
   dir/nested/m
   dir2/e
   dir2/k
   dir2/l
   f
   g
 
 Add some unknown files and refresh the dirstate
 
   $ touch -t 200001010020 $extra_files
   $ hg add dir/o
   $ hg remove dir/nested/m
 
   $ hg st --config devel.dirstate.v2.data_update_mode=force-new
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ hg debugstate
   n 644          0 2000-01-01 00:00:00 dir/b
   n 644          0 2000-01-01 00:00:00 dir/c
   n 644          0 2000-01-01 00:00:00 dir/d
   n 644          0 2000-01-01 00:10:00 dir/i
   n 644          0 2000-01-01 00:10:00 dir/j
   n 644          0 2000-01-01 00:00:00 dir/nested/a
   n 644          0 2000-01-01 00:10:00 dir/nested/h
   r ?????????????????????????????????? dir/nested/m (glob)
   a ?????????????????????????????????? dir/o (glob)
   n 644          0 2000-01-01 00:00:00 dir2/e
   n 644          0 2000-01-01 00:10:00 dir2/k
   n 644          0 2000-01-01 00:10:00 dir2/l
   n 644          0 2000-01-01 00:00:00 f
   n 644          0 2000-01-01 00:10:00 g
   $ hg debugstate > ../reference
   $ cd ..
 
 Actual Testing
 ==============
 
 Race with a `hg add`
 -------------------
 
   $ cp -a reference-repo race-with-add
   $ cd race-with-add
 
 spin a `hg status` with some caches to update
 
   $ hg st >$TESTTMP/status-race-lock.out 2>$TESTTMP/status-race-lock.log \
   > --config rhg.on-unsupported=abort \
   > --config ${cfg}=$TESTTMP/status-race-lock \
   > &
   $ $RUNTESTDIR/testlib/wait-on-file 5 $TESTTMP/status-race-lock.waiting
 
 Add a file
 
   $ hg $d2args add dir/n
   $ touch $TESTTMP/status-race-lock
   $ wait
 
 The file should in a "added" state
 
   $ hg status
   A dir/n
   A dir/o
   R dir/nested/m
   ? p
   ? q
 
 The status process should return a consistent result and not crash.
 
 #if dirstate-v1
   $ cat $TESTTMP/status-race-lock.out
   A dir/n
   A dir/o
   R dir/nested/m
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
 #if rhg
 #if pre-all-read
   $ cat $TESTTMP/status-race-lock.out
   A dir/n
   A dir/o
   R dir/nested/m
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
 #if dirstate-v2-append
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
   $ cat $TESTTMP/status-race-lock.out
   $ cat $TESTTMP/status-race-lock.log
   abort: dirstate-v2 parse error: not enough bytes on disk
 #endif
 #endif
 #else
 #if rust
 #if dirstate-v2-rewrite
   $ cat $TESTTMP/status-race-lock.out
   $ cat $TESTTMP/status-race-lock.log
   abort: $ENOENT$: '$TESTTMP/race-with-add/.hg/dirstate.* (glob)
 #else
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #endif
 #else
   $ cat $TESTTMP/status-race-lock.out
+  A dir/n
+  A dir/o
+  R dir/nested/m
+  ? p
+  ? q
   $ cat $TESTTMP/status-race-lock.log
-  abort: $ENOENT$: '$TESTTMP/race-with-add/.hg/dirstate.* (glob)
 #endif
 #endif
 #endif
 
 final cleanup
 
   $ rm $TESTTMP/status-race-lock $TESTTMP/status-race-lock.waiting
   $ cd ..
 
 Race with a `hg commit`
 -----------------------
 
   $ cp -a reference-repo race-with-commit
   $ cd race-with-commit
 
 spin a `hg status with some cache to update
 
   $ hg st >$TESTTMP/status-race-lock.out 2>$TESTTMP/status-race-lock.log \
   > --config rhg.on-unsupported=abort \
   > --config ${cfg}=$TESTTMP/status-race-lock \
   > &
   $ $RUNTESTDIR/testlib/wait-on-file 5 $TESTTMP/status-race-lock.waiting
 
 Add a do a commit
 
   $ hg status
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ hg $d2args commit -m 'racing commit'
   $ touch $TESTTMP/status-race-lock
   $ wait
 
 commit was created, and status is now clean
 
   $ hg log -GT '{node|short} {desc}\n'
   @  02a67a77ee9b racing commit
   |
   o  9a86dcbfb938 more files to have two commit
   |
   o  4f23db756b09 recreate a bunch of files to facilitate dirstate-v2 append
   
   $ hg status
   ? dir/n
   ? p
   ? q
 
 The status process should return a consistent result and not crash.
 
 #if dirstate-v1
   $ cat $TESTTMP/status-race-lock.out
   M dir/o (no-rhg !)
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
   warning: ignoring unknown working parent 02a67a77ee9b! (no-rhg !)
 #else
 #if rhg
 #if pre-all-read
   $ cat $TESTTMP/status-race-lock.out
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
 #if dirstate-v2-append
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
   $ cat $TESTTMP/status-race-lock.out
   $ cat $TESTTMP/status-race-lock.log
   abort: dirstate-v2 parse error: not enough bytes on disk
 #endif
 #endif
 #else
 #if rust
 #if dirstate-v2-rewrite
   $ cat $TESTTMP/status-race-lock.out
   $ cat $TESTTMP/status-race-lock.log
   abort: $ENOENT$: '$TESTTMP/race-with-commit/.hg/dirstate.* (glob)
 #else
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #endif
 #else
   $ cat $TESTTMP/status-race-lock.out
+  M dir/o
+  ? dir/n
+  ? p
+  ? q
   $ cat $TESTTMP/status-race-lock.log
-  abort: $ENOENT$: '$TESTTMP/race-with-commit/.hg/dirstate.* (glob)
+  warning: ignoring unknown working parent 02a67a77ee9b!
 #endif
 #endif
 #endif
 
 final cleanup
 
   $ rm $TESTTMP/status-race-lock $TESTTMP/status-race-lock.waiting
   $ cd ..
 
 Race with a `hg update`
 -----------------------
 
   $ cp -a reference-repo race-with-update
   $ cd race-with-update
 
 spin a `hg status` with some caches to update
 
   $ hg st >$TESTTMP/status-race-lock.out 2>$TESTTMP/status-race-lock.log \
   > --config rhg.on-unsupported=abort \
   > --config ${cfg}=$TESTTMP/status-race-lock \
   > &
   $ $RUNTESTDIR/testlib/wait-on-file 5 $TESTTMP/status-race-lock.waiting
 do an update
 
   $ hg status
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ hg log -GT '{node|short} {desc}\n'
   @  9a86dcbfb938 more files to have two commit
   |
   o  4f23db756b09 recreate a bunch of files to facilitate dirstate-v2 append
   
   $ hg $d2args update --merge ".~1"
   0 files updated, 0 files merged, 6 files removed, 0 files unresolved
   $ touch $TESTTMP/status-race-lock
   $ wait
 #if rhg dirstate-v2-append pre-some-read
   $ hg log -GT '{node|short} {desc}\n'
   @  9a86dcbfb938 more files to have two commit
   |
   o  4f23db756b09 recreate a bunch of files to facilitate dirstate-v2 append
   
   $ hg status
   A dir/o
   R dir/nested/m
   ! dir/i
   ! dir/j
   ! dir/nested/h
   ! dir2/k
   ! dir2/l
   ! g
   ? dir/n
   ? p
   ? q
 #else
   $ hg log -GT '{node|short} {desc}\n'
   o  9a86dcbfb938 more files to have two commit
   |
   @  4f23db756b09 recreate a bunch of files to facilitate dirstate-v2 append
   
   $ hg status
   A dir/o
   ? dir/n
   ? p
   ? q
 #endif
 
 The status process should return a consistent result and not crash.
 
 #if dirstate-v1
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
 #if rhg
 #if pre-all-read
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
 #if dirstate-v2-append
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   R dir/nested/m
   ! dir/i
   ! dir/j
   ! dir/nested/h
   ! dir2/k
   ! dir2/l
   ! g
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
   $ cat $TESTTMP/status-race-lock.out
   $ cat $TESTTMP/status-race-lock.log
   abort: dirstate-v2 parse error: not enough bytes on disk
 #endif
 #endif
 #else
 #if rust
 #if dirstate-v2-rewrite
   $ cat $TESTTMP/status-race-lock.out
   $ cat $TESTTMP/status-race-lock.log
   abort: $ENOENT$: '$TESTTMP/race-with-update/.hg/dirstate.* (glob)
 #else
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   R dir/nested/m
   ! dir/i
   ! dir/j
   ! dir/nested/h
   ! dir2/k
   ! dir2/l
   ! g
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #endif
 #else
   $ cat $TESTTMP/status-race-lock.out
+  A dir/o
+  ? dir/n
+  ? p
+  ? q
   $ cat $TESTTMP/status-race-lock.log
-  abort: $ENOENT$: '$TESTTMP/race-with-update/.hg/dirstate.* (glob)
 #endif
 #endif
 #endif
 
 final cleanup
 
   $ rm $TESTTMP/status-race-lock $TESTTMP/status-race-lock.waiting
   $ cd ..
 
 Race with a cache updating `hg status`
 --------------------------------------
 
 It is interesting to race with "read-only" operation (that still update its cache)
 
   $ cp -a reference-repo race-with-status
   $ cd race-with-status
 
 spin a `hg status` with some caches to update
 
   $ hg st >$TESTTMP/status-race-lock.out 2>$TESTTMP/status-race-lock.log \
   > --config rhg.on-unsupported=abort \
   > --config ${cfg}=$TESTTMP/status-race-lock \
   > &
   $ $RUNTESTDIR/testlib/wait-on-file 5 $TESTTMP/status-race-lock.waiting
 do an update
 
   $ touch -t 200001020006 f
   $ hg $d2args status
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ touch $TESTTMP/status-race-lock
   $ wait
 
 The status process should return a consistent result and not crash.
 
 #if dirstate-v1
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
 #if rhg
 #if pre-all-read
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
 #if dirstate-v2-append
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #else
   $ cat $TESTTMP/status-race-lock.out
   $ cat $TESTTMP/status-race-lock.log
   abort: dirstate-v2 parse error: not enough bytes on disk
 #endif
 #endif
 #else
 #if rust
 #if dirstate-v2-rewrite
   $ cat $TESTTMP/status-race-lock.out
   $ cat $TESTTMP/status-race-lock.log
   abort: $ENOENT$: '$TESTTMP/race-with-status/.hg/dirstate.* (glob)
 #else
   $ cat $TESTTMP/status-race-lock.out
   A dir/o
   R dir/nested/m
   ? dir/n
   ? p
   ? q
   $ cat $TESTTMP/status-race-lock.log
 #endif
 #else
   $ cat $TESTTMP/status-race-lock.out
+  A dir/o
+  R dir/nested/m
+  ? dir/n
+  ? p
+  ? q
   $ cat $TESTTMP/status-race-lock.log
-  abort: $ENOENT$: '$TESTTMP/race-with-status/.hg/dirstate.* (glob)
 #endif
 #endif
 #endif
 
 final cleanup
 
   $ rm $TESTTMP/status-race-lock $TESTTMP/status-race-lock.waiting
   $ cd ..