status: hack up various things to not assume ".hg" dot dir

Summary:
Update watchman queries, Python walker, and Rust walker to use the repo's identity's dot dir instead of hard coding ".hg".

I was able to pass the dot dir around in most places, but I resorted to re-sniffing the identity in the PhysicalFileSystem.

Reviewed By: DurhamG

Differential Revision: D39105266

fbshipit-source-id: a58f75889c4b1d4ea3b2e04817224c26b21a33ea

Author: Muir Manders

eden/scm/edenscm/ext/fsmonitor/__init__.py

@@ -313,7 +313,14 @@ def _finddirs(ui, fs):
             "expression": [
                 "allof",
                 ["type", "d"],
-                ["not", ["anyof", ["dirname", ".hg"], ["name", ".hg", "wholename"]]],
+                [
+                    "not",
+                    [
+                        "anyof",
+                        ["dirname", ui.identity.dotdir()],
+                        ["name", ui.identity.dotdir(), "wholename"],
+                    ],
+                ],
             ],
             "sync_timeout": int(state.timeout * 1000),
             "empty_on_fresh_instance": state.walk_on_invalidate,
@@ -477,7 +484,11 @@ def dirfilter(path):
         # Use the user-configured timeout for the query.
         # Add a little slack over the top of the user query to allow for
         # overheads while transferring the data
-        excludes = ["anyof", ["dirname", ".hg"], ["name", ".hg", "wholename"]]
+        excludes = [
+            "anyof",
+            ["dirname", self._ui.identity.dotdir()],
+            ["name", self._ui.identity.dotdir(), "wholename"],
+        ]
         # Exclude submodules.
         if git.isgitformat(self._repo):
             submods = git.parsesubmodules(self._repo[None])
@@ -723,7 +734,7 @@ def nf():
     state.setdroplist(droplist)
     state.setignorelist(ignorelist)
 
-    results.pop(".hg", None)
+    results.pop(self.ui.identity.dotdir(), None)
     return pycompat.iteritems(results)
 
 
@@ -979,7 +990,7 @@ def _detectrace(self, match=None):
                     "expression": [
                         "allof",
                         ["type", "f"],
-                        ["not", ["anyof", ["dirname", ".hg"]]],
+                        ["not", ["anyof", ["dirname", ui.identity.dotdir()]]],
                     ],
                     "sync_timeout": int(state.timeout * 1000),
                     "empty_on_fresh_instance": True,

eden/scm/edenscm/ext/fsmonitor/state.py

@@ -156,7 +156,11 @@ def set(self, clock, ignorehash, notefiles):
 
     def invalidate(self, reason=None):
         try:
-            os.unlink(os.path.join(self._rootdir, ".hg", "fsmonitor.state"))
+            os.unlink(
+                os.path.join(
+                    self._rootdir, self._ui.identity.dotdir(), "fsmonitor.state"
+                )
+            )
         except OSError as inst:
             if inst.errno != errno.ENOENT:
                 raise

eden/scm/edenscm/filesystem.py

@@ -268,7 +268,9 @@ def bad(self, path, msg):
 
         traversedir = bool(match.traversedir)
         threadcount = self.ui.configint("workingcopy", "rustwalkerthreads")
-        walker = workingcopy.walker(join(""), match, traversedir, threadcount)
+        walker = workingcopy.walker(
+            join(""), self.ui.identity.dotdir(), match, traversedir, threadcount
+        )
         for fn in walker:
             fn = self.dirstate.normalize(fn)
             st = util.lstat(join(fn))
@@ -367,16 +369,18 @@ def _walk(self, match, listignored=False):
         explicitfiles = set(match.files())
         explicitdirs = set(util.dirs(explicitfiles))
 
+        dotdir = self.ui.identity.dotdir()
+
         work = [""]
         wadd = work.append
         seen = set()
         while work:
             nd = work.pop()
-            if not match.visitdir(nd) or nd == ".hg":
+            if not match.visitdir(nd) or nd == dotdir:
                 continue
             skip = None
             if nd != "":
-                skip = ".hg"
+                skip = dotdir
             try:
                 entries = listdir(join(nd), stat=True, skip=skip)
             except OSError as inst:

eden/scm/edenscmnative/bindings/modules/pyworkingcopy/src/lib.rs

@@ -39,9 +39,22 @@ pub fn init_module(py: Python, package: &str) -> PyResult<PyModule> {
 py_class!(class walker |py| {
     data inner: RefCell<Walker<Arc<dyn Matcher + Sync + Send>>>;
     data _errors: RefCell<Vec<Error>>;
-    def __new__(_cls, root: PyPathBuf, pymatcher: PyObject, include_directories: bool, thread_count: u8) -> PyResult<walker> {
+    def __new__(
+        _cls,
+        root: PyPathBuf,
+        dot_dir: String,
+        pymatcher: PyObject,
+        include_directories: bool,
+        thread_count: u8,
+    ) -> PyResult<walker> {
         let matcher = extract_matcher(py, pymatcher)?;
-        let walker = Walker::new(root.to_path_buf(), matcher, include_directories, thread_count).map_pyerr(py)?;
+        let walker = Walker::new(
+            root.to_path_buf(),
+            dot_dir,
+            matcher,
+            include_directories,
+            thread_count,
+        ).map_pyerr(py)?;
         walker::create_instance(py, RefCell::new(walker), RefCell::new(Vec::new()))
     }
 

eden/scm/lib/workingcopy/src/physicalfs.rs

@@ -71,8 +71,11 @@ impl PendingChangesTrait for PhysicalFileSystem {
         &self,
         matcher: Arc<dyn Matcher + Send + Sync + 'static>,
     ) -> Result<Box<dyn Iterator<Item = Result<PendingChangeResult>>>> {
+        let root = self.vfs.root().to_path_buf();
+        let ident = identity::must_sniff_dir(&root)?;
         let walker = Walker::new(
-            self.vfs.root().to_path_buf(),
+            root,
+            ident.dot_dir().to_string(),
             matcher.clone(),
             false,
             self.num_threads,

eden/scm/lib/workingcopy/src/walker.rs

@@ -105,18 +105,25 @@ where
     /// multi-threaded walker will be created.
     pub fn new(
         root: PathBuf,
+        dot_dir: String,
         matcher: M,
         include_directories: bool,
         num_threads: u8,
     ) -> Result<Self> {
         let inner = match NonZeroU8::new(num_threads) {
             Some(num_threads) => WalkerType::Multi(MultiWalker::new(
                 root,
+                dot_dir,
                 matcher,
                 include_directories,
                 num_threads,
             )?),
-            None => WalkerType::Single(SingleWalker::new(root, matcher, include_directories)?),
+            None => WalkerType::Single(SingleWalker::new(
+                root,
+                dot_dir,
+                matcher,
+                include_directories,
+            )?),
         };
         Ok(Walker(inner))
     }
@@ -148,13 +155,19 @@ struct SingleWalker<M> {
     results: Vec<Result<WalkEntry>>,
     matcher: M,
     include_directories: bool,
+    dot_dir: String,
 }
 
 impl<M> SingleWalker<M>
 where
     M: Matcher,
 {
-    pub fn new(root: PathBuf, matcher: M, include_directories: bool) -> Result<Self> {
+    pub fn new(
+        root: PathBuf,
+        dot_dir: String,
+        matcher: M,
+        include_directories: bool,
+    ) -> Result<Self> {
         let mut dir_matches = vec![];
         if matcher.matches_directory(&RepoPathBuf::new())? != DirectoryMatch::Nothing {
             dir_matches.push(RepoPathBuf::new());
@@ -165,6 +178,7 @@ where
             results: Vec::new(),
             matcher,
             include_directories,
+            dot_dir,
         };
         Ok(walker)
     }
@@ -190,7 +204,7 @@ where
                     .push(Ok(WalkEntry::File(candidate_path, entry.metadata()?)));
             }
         } else if filetype.is_dir() {
-            if filename.as_str() != ".hg"
+            if filename.as_str() != self.dot_dir
                 && self
                     .matcher
                     .matches_directory(candidate_path.as_repo_path())?
@@ -214,7 +228,7 @@ where
             }
             let abs_next_dir = self.root.join(next_dir.as_str());
             // Don't process the directory if it contains a .hg directory, unless it's the root.
-            if next_dir.is_empty() || !Path::exists(&abs_next_dir.join(".hg")) {
+            if next_dir.is_empty() || !Path::exists(&abs_next_dir.join(&self.dot_dir)) {
                 for entry in fs::read_dir(abs_next_dir)
                     .map_err(|e| WalkError::IOError(next_dir.clone(), e))?
                 {
@@ -271,6 +285,7 @@ struct MultiWalker<M> {
     result_receiver: Receiver<Result<WalkEntry>>,
     has_walked: bool,
     payload: Arc<WalkerData<M>>,
+    dot_dir: String,
 }
 
 impl<M> MultiWalker<M>
@@ -285,6 +300,7 @@ where
 
     pub fn new(
         root: PathBuf,
+        dot_dir: String,
         matcher: M,
         include_directories: bool,
         num_threads: NonZeroU8,
@@ -308,13 +324,15 @@ where
                 matcher,
                 include_directories,
             }),
+            dot_dir,
         })
     }
 
     // WARNING: SIDE EFFECTS - if entry matches and is child directory, will push
     // child and increment busy_nodes atomic.
     fn match_entry_and_enqueue(
         dir: &RepoPathBuf,
+        dot_dir: &str,
         entry: DirEntry,
         shared_data: Arc<WalkerData<M>>,
     ) -> Result<()> {
@@ -339,7 +357,7 @@ where
                     .enqueue_result(Ok(WalkEntry::File(candidate_path, entry.metadata()?)))?;
             }
         } else if filetype.is_dir() {
-            if filename.as_str() != ".hg"
+            if filename.as_str() != dot_dir
                 && shared_data
                     .matcher
                     .matches_directory(candidate_path.as_repo_path())?
@@ -368,6 +386,7 @@ where
 
         for _t in 0..self.threads.capacity() {
             let shared_data = self.payload.clone();
+            let dot_dir = self.dot_dir.clone();
 
             // TODO make sure that _t is different for each thread
             self.threads.push(thread::spawn(move || {
@@ -392,6 +411,7 @@ where
                                         entry.map_err(|e| WalkError::IOError(dir.clone(), e))?;
                                     if let Err(e) = MultiWalker::match_entry_and_enqueue(
                                         &dir,
+                                        &dot_dir,
                                         entry,
                                         shared_data.clone(),
                                     ) {
@@ -496,7 +516,7 @@ mod tests {
         let files = vec!["dirA/a.txt", "b.txt"];
         let root_dir = create_directory(&directories, &files)?;
         let root_path = PathBuf::from(root_dir.path());
-        let walker = SingleWalker::new(root_path, NeverMatcher::new(), false)?;
+        let walker = SingleWalker::new(root_path, ".hg".to_string(), NeverMatcher::new(), false)?;
         let walked_files: Result<Vec<_>> = walker.collect();
         let walked_files = walked_files?;
         assert!(walked_files.is_empty());
@@ -509,7 +529,7 @@ mod tests {
         let files = vec!["dirA/a.txt", "dirA/b.txt", "dirB/dirC/dirD/c.txt"];
         let root_dir = create_directory(&directories, &files)?;
         let root_path = PathBuf::from(root_dir.path());
-        let walker = SingleWalker::new(root_path, AlwaysMatcher::new(), false)?;
+        let walker = SingleWalker::new(root_path, ".hg".to_string(), AlwaysMatcher::new(), false)?;
         let walked_files: Result<Vec<_>> = walker.collect();
         let walked_files = walked_files?;
         assert_eq!(walked_files.len(), 3);
@@ -527,6 +547,7 @@ mod tests {
         let root_path = PathBuf::from(root_dir.path());
         let walker = SingleWalker::new(
             root_path,
+            ".hg".to_string(),
             TreeMatcher::from_rules(["foo/bar/**"].iter()).unwrap(),
             false,
         )?;
@@ -546,7 +567,7 @@ mod tests {
         let files = vec!["dirA/a.txt", "dirA/b.txt", "dirB/dirC/dirD/c.txt"];
         let root_dir = create_directory(&directories, &files)?;
         let root_path = PathBuf::from(root_dir.path());
-        let walker = SingleWalker::new(root_path, AlwaysMatcher::new(), true)?;
+        let walker = SingleWalker::new(root_path, ".hg".to_string(), AlwaysMatcher::new(), true)?;
         let walked_files: Result<Vec<_>> = walker.collect();
         let walked_files = walked_files?;
         // Includes root dir ""
@@ -575,6 +596,7 @@ mod tests {
         let root_path = PathBuf::from(root_dir.path());
         let walker = MultiWalker::new(
             root_path,
+            ".hg".to_string(),
             NeverMatcher::new(),
             false,
             NonZeroU8::new(5).unwrap(),
@@ -593,6 +615,7 @@ mod tests {
         let root_path = PathBuf::from(root_dir.path());
         let walker = MultiWalker::new(
             root_path,
+            ".hg".to_string(),
             AlwaysMatcher::new(),
             false,
             NonZeroU8::new(1).unwrap(),
@@ -614,6 +637,7 @@ mod tests {
         let root_path = PathBuf::from(root_dir.path());
         let walker = MultiWalker::new(
             root_path,
+            ".hg".to_string(),
             AlwaysMatcher::new(),
             false,
             NonZeroU8::new(2).unwrap(),
@@ -635,6 +659,7 @@ mod tests {
         let root_path = PathBuf::from(root_dir.path());
         let walker = MultiWalker::new(
             root_path,
+            ".hg".to_string(),
             AlwaysMatcher::new(),
             false,
             NonZeroU8::new(u8::MAX).unwrap(),
@@ -656,6 +681,7 @@ mod tests {
         let root_path = PathBuf::from(root_dir.path());
         let walker = MultiWalker::new(
             root_path,
+            ".hg".to_string(),
             TreeMatcher::from_rules(["foo/bar/**"].iter()).unwrap(),
             false,
             NonZeroU8::new(4).unwrap(),
@@ -678,6 +704,7 @@ mod tests {
         let root_path = PathBuf::from(root_dir.path());
         let walker = MultiWalker::new(
             root_path,
+            ".hg".to_string(),
             AlwaysMatcher::new(),
             true,
             NonZeroU8::new(2).unwrap(),

eden/scm/tests/test-identity.t

@@ -53,8 +53,7 @@ Clone can create a ".sl" repo.
   wlock.lock
 
   $ cd cloned
-Status kind of runs, but doesn't ignore ".sl" properly (for non-watchman)
-  $ LOG=configparser::hg=info hg status | head -1
-  ? .sl/.dir_lock (?)
+Status works in ".sl" repo
+  $ LOG=configparser::hg=info hg status -A
    INFO configparser::hg: loading config repo_path=Some("$TESTTMP/clone_me/cloned")
-
+  C foo