Reintroduce the Simplified Open Options

Author: Kerollmops

examples/heed3-encryption.rs

@@ -21,7 +21,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     Argon2::default().hash_password_into(password.as_bytes(), salt.as_bytes(), &mut key)?;
 
     // We open the environment
-    let mut options = EnvOpenOptions::new().encrypt_with::<ChaCha20Poly1305>(key);
+    let mut options = EnvOpenOptions::<ChaCha20Poly1305>::new_encrypted_with(key);
     let env = unsafe {
         options
             .map_size(10 * 1024 * 1024) // 10MB

heed/src/env/clear.rs

@@ -13,11 +13,17 @@ use synchronoise::SignalEvent;
 
 #[cfg(windows)]
 use crate::env::OsStrExtLmdb as _;
-use crate::env::{canonicalize_path, Env, EnvEntry, EnvFlags, EnvInner, OPENED_ENV};
+use crate::env::{canonicalize_path, Env, EnvFlags, EnvInner, OPENED_ENV};
 use crate::mdb::ffi;
 use crate::mdb::lmdb_error::mdb_result;
 use crate::{Error, Result};
 
+pub struct EnvEntry {
+    pub(super) env: Option<Env>,
+    pub(super) signal_event: Arc<SignalEvent>,
+    pub(super) options: EnvOpenOptions,
+}
+
 /// Options and flags which can be used to configure how an environment is opened.
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]

heed/src/env/encrypted.rs

@@ -10,19 +10,48 @@ use std::path::Path;
 use std::sync::Arc;
 use std::{fmt, io, ptr};
 
-use aead::consts::U0;
 use aead::generic_array::typenum::Unsigned;
-use aead::generic_array::GenericArray;
-use aead::{AeadCore, AeadMutInPlace, Key, KeyInit, KeySizeUser, Nonce, Tag};
+use aead::{AeadCore, AeadMutInPlace, Key, KeyInit, Nonce, Tag};
 use synchronoise::SignalEvent;
 
 #[cfg(windows)]
 use crate::env::OsStrExtLmdb as _;
-use crate::env::{canonicalize_path, Env, EnvEntry, EnvFlags, EnvInner, OPENED_ENV};
+use crate::env::{canonicalize_path, Env, EnvFlags, EnvInner, OPENED_ENV};
 use crate::mdb::ffi;
 use crate::mdb::lmdb_error::mdb_result;
 use crate::{Error, Result};
 
+pub struct EnvEntry {
+    pub(super) env: Option<Env>,
+    pub(super) signal_event: Arc<SignalEvent>,
+    pub(super) options: SimplifiedEncryptedOpenOptions,
+}
+
+/// A simplified version of the options that were used to open a given [`Env`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SimplifiedEncryptedOpenOptions {
+    /// The maximum size this [`Env`] with take in bytes or [`None`] if it was not specified.
+    pub map_size: Option<usize>,
+    /// The maximum number of concurrent readers or [`None`] if it was not specified.
+    pub max_readers: Option<u32>,
+    /// The maximum number of opened database or [`None`] if it was not specified.
+    pub max_dbs: Option<u32>,
+    /// The raw flags enabled for this [`Env`] or [`None`] if it was not specified.
+    pub flags: u32,
+}
+
+impl<E: AeadMutInPlace + KeyInit> From<&EnvOpenOptions<E>> for SimplifiedEncryptedOpenOptions {
+    fn from(eoo: &EnvOpenOptions<E>) -> SimplifiedEncryptedOpenOptions {
+        let EnvOpenOptions { encrypt: _, map_size, max_readers, max_dbs, flags } = eoo;
+        SimplifiedEncryptedOpenOptions {
+            map_size: *map_size,
+            max_readers: *max_readers,
+            max_dbs: *max_dbs,
+            flags: flags.bits(),
+        }
+    }
+}
+
 /// Options and flags which can be used to configure how an environment is opened.
 #[derive(Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -55,8 +84,8 @@ impl<E: AeadMutInPlace + KeyInit> EnvOpenOptions<E> {
     /// use std::path::Path;
     /// use argon2::Argon2;
     /// use chacha20poly1305::{ChaCha20Poly1305, Key};
-    /// use heed3::types::*;
-    /// use heed3::{EnvOpenOptions, Database};
+    /// use heed3_encryption::types::*;
+    /// use heed3_encryption::{EnvOpenOptions, Database};
     ///
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
     /// let env_path = Path::new("target").join("encrypt.mdb");
@@ -70,7 +99,7 @@ impl<E: AeadMutInPlace + KeyInit> EnvOpenOptions<E> {
     /// Argon2::default().hash_password_into(password.as_bytes(), salt.as_bytes(), &mut key)?;
     ///
     /// // We open the environment
-    /// let mut options = EnvOpenOptions::new().encrypt_with::<ChaCha20Poly1305>(key);
+    /// let mut options = EnvOpenOptions::<ChaCha20Poly1305>::new_encrypted_with(key);
     /// let env = unsafe {
     ///     options
     ///         .map_size(10 * 1024 * 1024) // 10MB
@@ -94,13 +123,13 @@ impl<E: AeadMutInPlace + KeyInit> EnvOpenOptions<E> {
     ///
     /// ## Example Showing limitations
     ///
-    /// ```compile_fail
+    /// ```compile_fail,E0499
     /// use std::fs;
     /// use std::path::Path;
     /// use argon2::Argon2;
     /// use chacha20poly1305::{ChaCha20Poly1305, Key};
-    /// use heed3::types::*;
-    /// use heed3::{EnvOpenOptions, Database};
+    /// use heed3_encryption::types::*;
+    /// use heed3_encryption::{EnvOpenOptions, Database};
     ///
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
     /// let env_path = Path::new("target").join("encrypt.mdb");
@@ -114,7 +143,7 @@ impl<E: AeadMutInPlace + KeyInit> EnvOpenOptions<E> {
     /// Argon2::default().hash_password_into(password.as_bytes(), salt.as_bytes(), &mut key)?;
     ///
     /// // We open the environment
-    /// let mut options = EnvOpenOptions::new().encrypt_with::<ChaCha20Poly1305>(key);
+    /// let mut options = EnvOpenOptions::<ChaCha20Poly1305>::new_encrypted_with(key);
     /// let env = unsafe {
     ///     options
     ///         .map_size(10 * 1024 * 1024) // 10MB
@@ -125,6 +154,11 @@ impl<E: AeadMutInPlace + KeyInit> EnvOpenOptions<E> {
     /// let key1 = "first-key";
     /// let key2 = "second-key";
     ///
+    /// // We create the database
+    /// let mut wtxn = env.write_txn()?;
+    /// let db: Database<Str, Str> = env.create_database(&mut wtxn, Some("first"))?;
+    /// wtxn.commit()?;
+    ///
     /// // Declare the read transaction as mutable because LMDB, when using encryption,
     /// // does not allow keeping keys between reads due to the use of an internal cache.
     /// let mut rtxn = env.read_txn()?;
@@ -263,7 +297,7 @@ impl<E: AeadMutInPlace + KeyInit> EnvOpenOptions<E> {
             Ok(path) => path,
         };
 
-        let original_options = SimplifiedOpenOptions::from(self);
+        let original_options = SimplifiedEncryptedOpenOptions::from(self);
         match lock.entry(path) {
             Entry::Occupied(entry) => {
                 let env = entry.get().env.clone().ok_or(Error::DatabaseClosing)?;
@@ -282,7 +316,7 @@ impl<E: AeadMutInPlace + KeyInit> EnvOpenOptions<E> {
                     let mut env: *mut ffi::MDB_env = ptr::null_mut();
                     mdb_result(ffi::mdb_env_create(&mut env))?;
 
-                    let encrypt_key = crate::into_val(self.encrypt);
+                    let encrypt_key = crate::into_val(&self.encrypt);
                     mdb_result(ffi::mdb_env_set_encrypt(
                         env,
                         Some(encrypt_func_wrapper::<E>),

heed/src/env/mod.rs

@@ -38,19 +38,15 @@ use clear as sub_env;
 mod encrypted;
 #[cfg(all(master3, encryption))]
 use encrypted as sub_env;
+#[cfg(all(master3, encryption))]
+pub use encrypted::SimplifiedEncryptedOpenOptions;
 
 /// The list of opened environments, the value is an optional environment, it is None
 /// when someone asks to close the environment, closing is a two-phase step, to make sure
 /// no one 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);
-
-pub struct EnvEntry {
-    env: Option<Env>,
-    signal_event: Arc<SignalEvent>,
-    options: EnvOpenOptions,
-}
+static OPENED_ENV: Lazy<RwLock<HashMap<PathBuf, sub_env::EnvEntry>>> = Lazy::new(RwLock::default);
 
 // Thanks to the mozilla/rkv project
 // Workaround the UNC path on Windows, see https://github.com/rust-lang/rust/issues/42869.
@@ -139,7 +135,7 @@ impl Drop for EnvInner {
 
         match lock.remove(&self.path) {
             None => panic!("It seems another env closed this env before"),
-            Some(EnvEntry { signal_event, .. }) => {
+            Some(sub_env::EnvEntry { signal_event, .. }) => {
                 unsafe {
                     ffi::mdb_env_close(self.env);
                 }
@@ -644,7 +640,7 @@ impl Env {
         let mut lock = OPENED_ENV.write().unwrap();
         match lock.get_mut(self.path()) {
             None => panic!("cannot find the env that we are trying to close"),
-            Some(EnvEntry { env, signal_event, .. }) => {
+            Some(sub_env::EnvEntry { env, signal_event, .. }) => {
                 // We remove the env from the global list and replace it with a None.
                 let _env = env.take();
                 let signal_event = signal_event.clone();

heed/src/lib.rs

@@ -153,7 +153,11 @@ pub enum Error {
     DatabaseClosing,
     /// Attempt to open [`Env`] with different options.
     BadOpenOptions {
+        /// The simplified options that were used to originally open this env.
+        #[cfg(all(master3, encryption))]
+        options: env::SimplifiedEncryptedOpenOptions,
         /// The options that were used to originally open this env.
+        #[cfg(not(all(master3, encryption)))]
         options: EnvOpenOptions,
         /// The env opened with the original options.
         env: Env,