Check env file with samefile.

Samefile abstract away differences between Unixes and windows to check
if two files lead to the same file on the underlying filesystem.

Author: darnuria

heed/Cargo.toml

@@ -21,6 +21,7 @@ once_cell = "1.16.0"
 page_size = "0.5.0"
 serde = { version = "1.0.151", features = ["derive"], optional = true }
 synchronoise = "1.0.1"
+same-file = "1.0.6"
 
 [dev-dependencies]
 serde = { version = "1.0.151", features = ["derive"] }

heed/src/env.rs

@@ -19,6 +19,7 @@ use std::{
 use std::{fmt, io, mem, ptr, sync};
 
 use once_cell::sync::Lazy;
+use same_file::Handle;
 use synchronoise::event::SignalEvent;
 
 use crate::mdb::error::mdb_result;
@@ -32,7 +33,10 @@ use crate::{
 /// noone tries to open the same environment between these two phases.
 ///
 /// Trying to open a None marked environment returns an error to the user trying to open it.
-static OPENED_ENV: Lazy<RwLock<HashMap<PathBuf, EnvEntry>>> = Lazy::new(RwLock::default);
+///
+/// [samefile::Handle] abstract the platform details of checking if the given paths points to
+///  the same file on the filesystem.
+static OPENED_ENV: Lazy<RwLock<HashMap<Handle, EnvEntry>>> = Lazy::new(RwLock::default);
 
 struct EnvEntry {
     env: Option<Env>,
@@ -180,22 +184,29 @@ impl EnvOpenOptions {
     pub fn open<P: AsRef<Path>>(&self, path: P) -> Result<Env> {
         let mut lock = OPENED_ENV.write().unwrap();
 
-        let path = match canonicalize_path(path.as_ref()) {
+        let (path, handle) = match canonicalize_path(path.as_ref()) {
             Err(err) => {
                 if err.kind() == NotFound && self.flags & (Flag::NoSubDir as u32) != 0 {
                     let path = path.as_ref();
                     match path.parent().zip(path.file_name()) {
-                        Some((dir, file_name)) => canonicalize_path(dir)?.join(file_name),
+                        Some((dir, file_name)) => {
+                            let handle = Handle::from_path(dir)?;
+                            let path = canonicalize_path(dir)?.join(file_name);
+                            (path, handle)
+                        }
                         None => return Err(err.into()),
                     }
                 } else {
                     return Err(err.into());
                 }
             }
-            Ok(path) => path,
+            Ok(path) => {
+                let handle = Handle::from_path(&path)?;
+                (path, handle)
+            }
         };
 
-        match lock.entry(path) {
+        match lock.entry(handle) {
             Entry::Occupied(entry) => {
                 let env = entry.get().env.clone().ok_or(Error::DatabaseClosing)?;
                 let options = entry.get().options.clone();
@@ -206,7 +217,6 @@ impl EnvOpenOptions {
                 }
             }
             Entry::Vacant(entry) => {
-                let path = entry.key();
                 let path_str = CString::new(path.as_os_str().as_bytes()).unwrap();
 
                 unsafe {
@@ -255,6 +265,7 @@ impl EnvOpenOptions {
                                 env,
                                 dbi_open_mutex: sync::Mutex::default(),
                                 path: path.clone(),
+                                handle: Handle::from_path(path)?,
                             };
                             let env = Env(Arc::new(inner));
                             let cache_entry = EnvEntry {
@@ -277,9 +288,11 @@ impl EnvOpenOptions {
 }
 
 /// Returns a struct that allows to wait for the effective closing of an environment.
-pub fn env_closing_event<P: AsRef<Path>>(path: P) -> Option<EnvClosingEvent> {
+pub fn env_closing_event<P: AsRef<Path>>(path: P) -> Result<Option<EnvClosingEvent>> {
     let lock = OPENED_ENV.read().unwrap();
-    lock.get(path.as_ref()).map(|e| EnvClosingEvent(e.signal_event.clone()))
+    let handle = Handle::from_path(path)?;
+
+    Ok(lock.get(&handle).map(|e| EnvClosingEvent(e.signal_event.clone())))
 }
 
 /// An environment handle constructed by using [`EnvOpenOptions`].
@@ -288,7 +301,7 @@ pub struct Env(Arc<EnvInner>);
 
 impl fmt::Debug for Env {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let EnvInner { env: _, dbi_open_mutex: _, path } = self.0.as_ref();
+        let EnvInner { env: _, dbi_open_mutex: _, path, .. } = self.0.as_ref();
         f.debug_struct("Env").field("path", &path.display()).finish_non_exhaustive()
     }
 }
@@ -297,6 +310,7 @@ struct EnvInner {
     env: *mut ffi::MDB_env,
     dbi_open_mutex: sync::Mutex<HashMap<u32, Option<(TypeId, TypeId)>>>,
     path: PathBuf,
+    handle: Handle,
 }
 
 unsafe impl Send for EnvInner {}
@@ -307,7 +321,7 @@ impl Drop for EnvInner {
     fn drop(&mut self) {
         let mut lock = OPENED_ENV.write().unwrap();
 
-        match lock.remove(&self.path) {
+        match lock.remove(&self.handle) {
             None => panic!("It seems another env closed this env before"),
             Some(EnvEntry { signal_event, .. }) => {
                 unsafe {
@@ -653,7 +667,7 @@ impl Env {
     /// when all references are dropped, the last one will eventually close the environment.
     pub fn prepare_for_closing(self) -> EnvClosingEvent {
         let mut lock = OPENED_ENV.write().unwrap();
-        match lock.get_mut(self.path()) {
+        match lock.get_mut(&self.0.handle) {
             None => panic!("cannot find the env that we are trying to close"),
             Some(EnvEntry { env, signal_event, .. }) => {
                 // We remove the env from the global list and replace it with a None.
@@ -797,7 +811,7 @@ mod tests {
         eprintln!("env closed successfully");
 
         // Make sure we don't have a reference to the env
-        assert!(env_closing_event(&dir.path()).is_none());
+        assert!(env_closing_event(&dir.path()).unwrap().is_none());
     }
 
     #[test]
@@ -830,6 +844,49 @@ mod tests {
             .unwrap();
     }
 
+    #[test]
+    #[cfg(unix)]
+    fn open_env_with_named_path_symlink() {
+        let dir = tempfile::tempdir().unwrap();
+        let dir_symlink = tempfile::tempdir().unwrap();
+
+        let env_name = dir.path().join("babar.mdb");
+        let symlink_name = dir_symlink.path().join("babar.mdb.link");
+        fs::create_dir_all(&env_name).unwrap();
+
+        std::os::unix::fs::symlink(&env_name, &symlink_name).unwrap();
+        let _env = EnvOpenOptions::new()
+            .map_size(10 * 1024 * 1024) // 10MB
+            .open(&symlink_name)
+            .unwrap();
+
+        let _env = EnvOpenOptions::new()
+            .map_size(10 * 1024 * 1024) // 10MB
+            .open(&symlink_name)
+            .unwrap();
+    }
+
+    #[test]
+    fn open_env_with_named_path_rename() {
+        let dir = tempfile::tempdir().unwrap();
+
+        let env_name = dir.path().join("babar.mdb");
+        fs::create_dir_all(&env_name).unwrap();
+
+        let _env = EnvOpenOptions::new()
+            .map_size(10 * 1024 * 1024) // 10MB
+            .open(&env_name)
+            .unwrap();
+
+        let env_renamed = dir.path().join("serafina.mdb");
+        std::fs::rename(&env_name, &env_renamed).unwrap();
+
+        let _env = EnvOpenOptions::new()
+            .map_size(10 * 1024 * 1024) // 10MB
+            .open(&env_renamed)
+            .unwrap();
+    }
+
     #[test]
     #[cfg(not(windows))]
     fn open_database_with_writemap_flag() {
@@ -853,6 +910,33 @@ mod tests {
         let _env = envbuilder.open(&dir.path().join("data.mdb")).unwrap();
     }
 
+    #[test]
+    #[cfg(unix)]
+    fn open_env_with_named_path_symlink_and_no_subdir() {
+        let dir = tempfile::tempdir().unwrap();
+        let dir_symlink = tempfile::tempdir().unwrap();
+        let env_name = dir.path().join("babar.mdb");
+        let symlink_name = dir_symlink.path().join("babar.mdb.link");
+
+        let mut envbuilder = EnvOpenOptions::new();
+        unsafe { envbuilder.flag(crate::Flag::NoSubDir) };
+        let _env = envbuilder
+            .map_size(10 * 1024 * 1024) // 10MB
+            .open(&env_name)
+            .unwrap();
+
+        std::os::unix::fs::symlink(&dir.path(), &symlink_name).unwrap();
+        let _env = envbuilder
+            .map_size(10 * 1024 * 1024) // 10MB
+            .open(&symlink_name)
+            .unwrap();
+
+        let _env = envbuilder
+            .map_size(10 * 1024 * 1024) // 10MB
+            .open(&env_name)
+            .unwrap();
+    }
+
     #[test]
     fn create_database_without_commit() {
         let dir = tempfile::tempdir().unwrap();