Add support for info,is_write_map,is_read_write,is_read_only

Author: wtdcode

Cargo.lock

@@ -48,7 +48,7 @@ rand_xorshift = "0.3"
 tempfile.workspace = true
 paste.workspace = true
 futures-util.workspace =true
-console-subscriber = "0.4"
+# console-subscriber = "0.4"
 # [[bench]]
 # name = "cursor"
 # harness = false

crates/mdbx-remote/Cargo.toml

@@ -97,7 +97,7 @@ fn generate_bindings(mdbx: &Path, out_file: &Path) {
         }
 
         fn add_derives(&self, _info: &bindgen::callbacks::DeriveInfo<'_>) -> Vec<String> {
-            let serde_list = &["MDBX_commit_latency", "MDBX_stat"];
+            let serde_list = &["MDBX_commit_latency", "MDBX_stat", "MDBX_envinfo"];
 
             for candidate in serde_list.iter() {
                 if _info.name.starts_with(candidate) {

crates/mdbx-remote/mdbx-sys/build.rs

@@ -8,8 +8,8 @@ use tokio_stream::Stream;
 use crate::{
     remote::{ClientError, RemoteCursor, RemoteDatabase, RemoteEnvironment, RemoteTransaction},
     service::RemoteMDBXClient,
-    CommitLatency, Cursor, Database, DatabaseFlags, Environment, EnvironmentFlags, Mode, Stat,
-    TableObject, Transaction, TransactionKind, WriteFlags, RO, RW,
+    CommitLatency, Cursor, Database, DatabaseFlags, Environment, EnvironmentFlags, EnvironmentKind,
+    Info, Mode, Stat, TableObject, Transaction, TransactionKind, WriteFlags, RO, RW,
 };
 
 type Result<T> = std::result::Result<T, ClientError>;
@@ -154,6 +154,32 @@ impl EnvironmentAny {
             Self::Remote(env) => Ok(env.stat().await?),
         }
     }
+
+    pub async fn info(&self) -> Result<Info> {
+        match self {
+            Self::Local(env) => Ok(env.info()?),
+            Self::Remote(env) => Ok(env.info().await?),
+        }
+    }
+
+    pub fn env_kind(&self) -> EnvironmentKind {
+        match self {
+            Self::Local(env) => env.env_kind(),
+            Self::Remote(env) => env.env_kind(),
+        }
+    }
+
+    pub fn is_write_map(&self) -> bool {
+        self.env_kind().is_write_map()
+    }
+
+    pub async fn is_read_write(&self) -> Result<bool> {
+        Ok(!self.is_read_only().await?)
+    }
+
+    pub async fn is_read_only(&self) -> Result<bool> {
+        Ok(matches!(self.info().await?.mode(), Mode::ReadOnly))
+    }
 }
 
 #[derive(Debug)]

crates/mdbx-remote/src/any.rs

@@ -4,7 +4,7 @@ use crate::{
     flags::EnvironmentFlags,
     transaction::{RO, RW},
     txn_manager::{TxnManager, TxnManagerMessage, TxnPtr},
-    Transaction, TransactionKind,
+    Mode, SyncMode, Transaction, TransactionKind,
 };
 use byteorder::{ByteOrder, NativeEndian};
 use mem::size_of;
@@ -73,14 +73,14 @@ impl Environment {
 
     /// Returns true if the environment was opened in [`crate::Mode::ReadWrite`] mode.
     #[inline]
-    pub fn is_read_write(&self) -> bool {
-        self.inner.env_kind.is_write_map()
+    pub fn is_read_write(&self) -> Result<bool> {
+        Ok(!self.is_read_only()?)
     }
 
     /// Returns true if the environment was opened in [`crate::Mode::ReadOnly`] mode.
     #[inline]
-    pub fn is_read_only(&self) -> bool {
-        !self.inner.env_kind.is_write_map()
+    pub fn is_read_only(&self) -> Result<bool> {
+        Ok(matches!(self.info()?.mode(), Mode::ReadOnly))
     }
 
     /// Returns the transaction manager.
@@ -372,7 +372,7 @@ impl GeometryInfo {
 /// Environment information.
 ///
 /// Contains environment information about the map size, readers, last txn id etc.
-#[derive(Debug)]
+#[derive(Debug, Serialize, Deserialize)]
 #[repr(transparent)]
 pub struct Info(ffi::MDBX_envinfo);
 
@@ -381,6 +381,35 @@ impl Info {
         GeometryInfo(self.0.mi_geo)
     }
 
+    pub const fn mode(&self) -> Mode {
+        let mode = self.0.mi_mode;
+        if (mode & ffi::MDBX_RDONLY) != 0 {
+            Mode::ReadOnly
+        } else {
+            if (mode & ffi::MDBX_SYNC_DURABLE) != 0 {
+                Mode::ReadWrite {
+                    sync_mode: SyncMode::Durable,
+                }
+            } else if (mode & ffi::MDBX_UTTERLY_NOSYNC) != 0 {
+                Mode::ReadWrite {
+                    sync_mode: SyncMode::UtterlyNoSync,
+                }
+            } else if (mode & ffi::MDBX_NOMETASYNC) != 0 {
+                Mode::ReadWrite {
+                    sync_mode: SyncMode::NoMetaSync,
+                }
+            } else if (mode & ffi::MDBX_SAFE_NOSYNC) != 0 {
+                Mode::ReadWrite {
+                    sync_mode: SyncMode::SafeNoSync,
+                }
+            } else {
+                Mode::ReadWrite {
+                    sync_mode: SyncMode::Durable,
+                }
+            }
+        }
+    }
+
     /// Size of memory map.
     #[inline]
     pub const fn map_size(&self) -> usize {
@@ -620,6 +649,12 @@ impl From<EnvironmentBuilder> for RemoteEnvironmentConfig {
     }
 }
 
+impl RemoteEnvironmentConfig {
+    pub(crate) fn env_kind(&self) -> EnvironmentKind {
+        self.kind
+    }
+}
+
 impl From<RemoteEnvironmentConfig> for EnvironmentBuilder {
     fn from(value: RemoteEnvironmentConfig) -> Self {
         Self {

crates/mdbx-remote/src/environment.rs

@@ -25,8 +25,8 @@ use tokio_stream::Stream;
 use crate::{
     environment::RemoteEnvironmentConfig,
     service::{RemoteMDBXClient, ServerError},
-    CommitLatency, DatabaseFlags, EnvironmentBuilder, Stat, TableObject, TransactionKind,
-    WriteFlags, RO, RW,
+    CommitLatency, DatabaseFlags, EnvironmentBuilder, EnvironmentKind, Info, Mode, Stat,
+    TableObject, TransactionKind, WriteFlags, RO, RW,
 };
 
 macro_rules! mdbx_try_optional {
@@ -111,6 +111,7 @@ pub(crate) struct RemoteEnvironmentInner {
     handle: u64,
     cl: RemoteMDBXClient,
     deadline: Duration,
+    kind: EnvironmentKind,
     ch: oneshot::Sender<()>,
 }
 
@@ -144,13 +145,15 @@ impl RemoteEnvironmentInner {
             tracing::debug!("Dispatcher dies");
         });
         let remote = RemoteEnvironmentConfig::from(builder);
+        let kind = remote.env_kind();
         let handle = client
             .open_env(context_deadline(deadline), path, remote)
             .await??;
         Ok(Self {
             handle: handle,
             cl: client,
             deadline: deadline,
+            kind: kind,
             ch: tx,
         })
     }
@@ -237,6 +240,30 @@ impl RemoteEnvironment {
             .env_stat(self.inner.context(), self.inner.handle)
             .await??)
     }
+
+    pub async fn info(&self) -> Result<Info> {
+        Ok(self
+            .inner
+            .cl
+            .env_info(self.inner.context(), self.inner.handle)
+            .await??)
+    }
+
+    pub fn env_kind(&self) -> EnvironmentKind {
+        self.inner.kind
+    }
+
+    pub fn is_write_map(&self) -> bool {
+        self.inner.kind.is_write_map()
+    }
+
+    pub async fn is_read_write(&self) -> Result<bool> {
+        Ok(!self.is_read_only().await?)
+    }
+
+    pub async fn is_read_only(&self) -> Result<bool> {
+        Ok(matches!(self.info().await?.mode(), Mode::ReadOnly))
+    }
 }
 
 #[derive(Debug, Clone)]

crates/mdbx-remote/src/remote.rs

@@ -6,7 +6,7 @@ use tokio::sync::RwLock;
 
 use crate::{
     environment::RemoteEnvironmentConfig, CommitLatency, Cursor, DatabaseFlags, Environment,
-    EnvironmentBuilder, Stat, Transaction, TransactionKind, WriteFlags, RO, RW,
+    EnvironmentBuilder, Info, Stat, Transaction, TransactionKind, WriteFlags, RO, RW,
 };
 
 #[tarpc::service]
@@ -18,6 +18,7 @@ pub trait RemoteMDBX {
     async fn env_sync(env: u64, force: bool) -> Result<bool, ServerError>;
     async fn env_close(env: u64) -> Result<(), ServerError>;
     async fn env_stat(env: u64) -> Result<Stat, ServerError>;
+    async fn env_info(env: u64) -> Result<Info, ServerError>;
 
     async fn tx_create_db(
         env: u64,
@@ -230,7 +231,26 @@ impl RemoteMDBX for RemoteMDBXServer {
             .ok_or(ServerError::NOENV)?
             .env
             .clone();
-        let ret = tokio::task::spawn_blocking(move || env.stat()).await??;
+        let ret = env.stat()?;
+
+        Ok(ret)
+    }
+
+    async fn env_info(
+        self,
+        _context: tarpc::context::Context,
+        env: u64,
+    ) -> Result<Info, ServerError> {
+        let env = self
+            .state
+            .read()
+            .await
+            .envs
+            .get(&env)
+            .ok_or(ServerError::NOENV)?
+            .env
+            .clone();
+        let ret = env.info()?;
 
         Ok(ret)
     }
@@ -250,6 +270,7 @@ impl RemoteMDBX for RemoteMDBXServer {
             .ok_or(ServerError::NOENV)?
             .env
             .clone();
+        // This can block for a very time, though not forever
         let ret = tokio::task::spawn_blocking(move || env.sync(force)).await??;
 
         Ok(ret)
@@ -344,7 +365,8 @@ impl RemoteMDBX for RemoteMDBXServer {
             if flags.contains(DatabaseFlags::CREATE) {
                 return Err(ServerError::NOWRITABLE);
             }
-            // This can block
+            // This can block? can it?
+            // But anyway opening databases should be not so frequent so overhead should be acceptable.
             tokio::task::spawn_blocking(move || tx.open_db(db.as_deref())).await??
         } else {
             return Err(ServerError::NOTX);
@@ -440,6 +462,7 @@ impl RemoteMDBX for RemoteMDBXServer {
             env.rwtxs.remove(&tx).ok_or(ServerError::NOTX)?
         };
 
+        // This can be slow, wrap it in spawn_blocking
         Ok(tokio::task::spawn_blocking(move || tx.tx.commit()).await??)
     }
 
@@ -487,6 +510,7 @@ impl RemoteMDBX for RemoteMDBXServer {
             .tx
             .clone();
 
+        // Can this block forever? Anyway, wrap it with spawn_blocking for safety.
         let new_tx = tokio::task::spawn_blocking(move || tx.begin_nested_txn()).await??;
 
         let mut lg = self.state.write().await;
@@ -518,11 +542,11 @@ impl RemoteMDBX for RemoteMDBXServer {
         let stat = if let Some(rw) = env.rwtxs.get(&tx) {
             let tx = rw.tx.clone();
             drop(lg);
-            tokio::task::spawn_blocking(move || tx.db_stat_with_dbi(dbi)).await??
+            tx.db_stat_with_dbi(dbi)?
         } else if let Some(ro) = env.rotxs.get(&tx) {
             let tx = ro.tx.clone();
             drop(lg);
-            tokio::task::spawn_blocking(move || tx.db_stat_with_dbi(dbi)).await??
+            tx.db_stat_with_dbi(dbi)?
         } else {
             return Err(ServerError::NOTX);
         };
@@ -550,6 +574,7 @@ impl RemoteMDBX for RemoteMDBXServer {
             .tx
             .clone();
 
+        // This can be slow
         tokio::task::spawn_blocking(move || tx.clear_db(dbi)).await??;
         Ok(())
     }

crates/mdbx-remote/src/service.rs

@@ -159,6 +159,27 @@ fn test_info() {
     // assert_eq!(info.last_pgno(), 1);
     // assert_eq!(info.last_txnid(), 0);
     assert_eq!(info.num_readers(), 0);
+    assert!(matches!(
+        info.mode(),
+        Mode::ReadWrite {
+            sync_mode: SyncMode::Durable
+        }
+    ));
+
+    drop(env);
+    let env = Environment::builder()
+        .set_geometry(Geometry {
+            size: Some(map_size..),
+            ..Default::default()
+        })
+        .set_flags(EnvironmentFlags {
+            mode: Mode::ReadOnly,
+            ..Default::default()
+        })
+        .open(dir.path())
+        .unwrap();
+    let info = env.info().unwrap();
+    assert!(matches!(info.mode(), Mode::ReadOnly));
 }
 
 #[test]