chore(merge): merged with other repo

Author: jgeluk

Diff for: .gitignore

@@ -8,3 +8,4 @@ Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
+bindings.rs

Diff for: .idea/rustrdf-rs.iml

@@ -0,0 +1,25 @@
+use crate::{Error, ServerConnection};
+use std::fmt::{Display, Formatter};
+
+#[derive(Clone)]
+pub struct DataStore {
+    pub(crate) name: String,
+}
+
+impl Display for DataStore {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "data store [{}]", self.name)
+    }
+}
+
+impl DataStore {
+    pub fn define(name: &str) -> Self {
+        Self {
+            name: name.to_string(),
+        }
+    }
+
+    pub fn create(self, server_connection: &ServerConnection) -> Result<Self, Error> {
+        server_connection.create_data_store(self)
+    }
+}

Diff for: src/data_store.rs

@@ -3,38 +3,58 @@
 
 use std::ffi::{CStr, CString};
 use std::fmt::{Display, Formatter};
+use std::os::unix::ffi::OsStrExt;
 use std::panic::AssertUnwindSafe;
 use std::path::Path;
 use std::ptr;
+use std::time::Instant;
 
 use crate::{
     root::{
         CDataStoreConnection, CDataStoreConnection_getID, CDataStoreConnection_getUniqueID,
         CDataStoreConnection_importDataFromFile, CException, CUpdateType,
     },
-    Error, Graph, Parameters, Prefixes, Statement, Transaction, TEXT_TURTLE,
+    DataStore, Error, Graph, Parameters, Prefixes, Statement, Transaction, TEXT_TURTLE,
 };
 
 pub struct DataStoreConnection {
+    pub data_store: DataStore,
     pub(crate) inner: *mut CDataStoreConnection,
+    started_at: Instant,
 }
 
 impl Display for DataStoreConnection {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.write_str("data store connection").unwrap();
-        match self.get_id() {
-            Ok(id) => write!(f, " id={}", id),
-            Err(error) => write!(f, " id=({:?})", error),
-        }
-        .unwrap();
+        f.write_str("connection").unwrap();
+        // match self.get_id() {
+        //     Ok(id) => write!(f, " id={}", id),
+        //     Err(error) => write!(f, " id=({:?})", error)
+        // }.unwrap();
         match self.get_unique_id() {
-            Ok(id) => write!(f, " unique-id={}", id),
-            Err(_error) => write!(f, " unique-id=(error could not get id)"),
+            Ok(id) => write!(f, " {}", id),
+            Err(_error) => write!(f, " (error could not get unique-id)"),
         }
+        .unwrap();
+        write!(f, " to {}", self.data_store)
+    }
+}
+
+impl Drop for DataStoreConnection {
+    fn drop(&mut self) {
+        let duration = self.started_at.elapsed();
+        log::info!("dropped {self} after {:?}", duration)
     }
 }
 
 impl DataStoreConnection {
+    pub(crate) fn new(data_store: DataStore, inner: *mut CDataStoreConnection) -> Self {
+        Self {
+            data_store,
+            inner,
+            started_at: Instant::now(),
+        }
+    }
+
     pub fn get_id(&self) -> Result<u32, Error> {
         let mut id: u32 = 0;
         CException::handle(AssertUnwindSafe(|| unsafe {
@@ -56,7 +76,10 @@ impl DataStoreConnection {
     where
         P: AsRef<Path>,
     {
-        log::debug!(
+        assert!(!self.inner.is_null(), "invalid datastore connection");
+
+        let rdf_file = file.as_ref().as_os_str().as_bytes();
+        log::trace!(
             "Importing file {} into graph {:} of {:}",
             file.as_ref().display(),
             graph,
@@ -65,11 +88,9 @@ impl DataStoreConnection {
 
         let c_graph_name = graph.as_c_string();
         let prefixes = Prefixes::default()?;
-        let file_name = CString::new(file.as_ref().file_name().unwrap().to_str().unwrap()).unwrap();
+        let file_name = CString::new(rdf_file).unwrap();
         let format_name = CString::new(TEXT_TURTLE.as_ref()).unwrap();
 
-        assert!(!self.inner.is_null());
-
         CException::handle(|| unsafe {
             CDataStoreConnection_importDataFromFile(
                 self.inner,
@@ -107,8 +128,7 @@ impl DataStoreConnection {
         //     CDataStoreConnection_rollbackTransaction(dataStoreConnection);
         //     return result;
         // }
-        let parameters = Parameters::empty()?;
-        parameters.fact_domain_all()?;
+        let parameters = Parameters::empty()?.fact_domain_all()?;
 
         let prefixes = Prefixes::default()?;
 

Diff for: src/data_store_connection.rs

@@ -17,6 +17,7 @@ pub enum Error {
     UNKNOWN,
     #[allow(dead_code)]
     UnknownResourceException,
+    CouldNotConnectToServer,
 }
 
 impl CException {

Diff for: src/exception.rs

@@ -11,14 +11,15 @@ use lazy_static::lazy_static;
 pub use mime::Mime;
 
 pub use cursor::Cursor;
+pub use data_store::DataStore;
 pub use data_store_connection::DataStoreConnection;
 pub use exception::Error;
 pub use graph::Graph;
 pub use parameters::Parameters;
 pub use prefixes::Prefixes;
 pub use role_creds::RoleCreds;
 pub use server::Server;
-pub use server_connection::Connection;
+pub use server_connection::ServerConnection;
 pub use statement::Statement;
 pub use transaction::Transaction;
 
@@ -27,6 +28,7 @@ lazy_static! {
 }
 
 mod cursor;
+mod data_store;
 mod data_store_connection;
 mod exception;
 mod graph;
@@ -36,7 +38,6 @@ mod role_creds;
 mod server;
 mod server_connection;
 mod statement;
-mod tests;
 mod transaction;
 
 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

Diff for: src/lib.rs

@@ -9,21 +9,25 @@ use crate::root::{
 };
 use crate::Error;
 use alloc::ffi::CString;
+use std::fmt::{Display, Formatter};
 use std::panic::AssertUnwindSafe;
 use std::ptr;
 
 pub struct Parameters {
     pub(crate) inner: *mut CParameters,
 }
 
+impl Display for Parameters {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Parameters[]") // TODO: show keys and values (currently not possible)
+    }
+}
+
 impl Drop for Parameters {
     fn drop(&mut self) {
         unsafe {
-            if !self.inner.is_null() {
-                CParameters_destroy(self.inner);
-                self.inner = ptr::null_mut();
-                log::debug!("Destroyed params");
-            }
+            CParameters_destroy(self.inner);
+            log::debug!("Destroyed params");
         }
     }
 }
@@ -47,7 +51,13 @@ impl Parameters {
         Ok(())
     }
 
-    pub fn fact_domain_all(&self) -> Result<(), Error> {
-        self.set_string("fact-domain", "all")
+    pub fn fact_domain_all(self) -> Result<Self, Error> {
+        self.set_string("fact-domain", "all")?;
+        Ok(self)
+    }
+
+    pub fn switch_off_file_access_sandboxing(self) -> Result<Self, Error> {
+        self.set_string("sandbox-directory", "")?;
+        Ok(self)
     }
 }

Diff for: src/parameters.rs

@@ -6,27 +6,36 @@ use std::panic::AssertUnwindSafe;
 use std::ptr;
 
 use crate::exception::Error;
+use crate::Error::CouldNotConnectToServer;
 use crate::{
     root::{
-        CException, CParameters_getEmptyParameters, CServerConnection,
-        CServerConnection_newServerConnection, CServer_createFirstLocalServerRole,
-        CServer_startLocalServer,
+        CException, CServerConnection, CServerConnection_newServerConnection,
+        CServer_createFirstLocalServerRole, CServer_startLocalServer,
     },
-    Connection, RoleCreds,
+    Parameters, RoleCreds, ServerConnection,
 };
 
-pub struct Server {}
+pub struct Server {
+    default_role_creds: RoleCreds,
+}
 
 impl Server {
-    pub fn start(role_creds: &RoleCreds) -> Result<Self, Error> {
-        log::debug!("Starting local RDFox server");
-        CException::handle(|| unsafe {
-            CServer_startLocalServer(CParameters_getEmptyParameters())
-        })?;
+    pub fn start(role_creds: RoleCreds) -> Result<Self, Error> {
+        Self::start_with_parameters(role_creds, &Parameters::empty()?)
+    }
 
-        let server = Server {};
+    pub fn start_with_parameters(
+        role_creds: RoleCreds,
+        params: &Parameters,
+    ) -> Result<Self, Error> {
+        log::debug!("Starting local RDFox server with {params}");
+        CException::handle(|| unsafe { CServer_startLocalServer(params.inner) })?;
 
-        server.create_role(role_creds)?;
+        let server = Server {
+            default_role_creds: role_creds,
+        };
+
+        server.create_role(&server.default_role_creds)?;
 
         log::debug!("Local RDFox server has been started");
         Ok(server)
@@ -43,7 +52,11 @@ impl Server {
         Ok(())
     }
 
-    pub fn connection(&self, role_creds: &RoleCreds) -> Result<Connection, Error> {
+    pub fn connection_with_default_role(&self) -> Result<ServerConnection, Error> {
+        self.connection(&self.default_role_creds)
+    }
+
+    pub fn connection(&self, role_creds: &RoleCreds) -> Result<ServerConnection, Error> {
         let c_role_name = CString::new(role_creds.role_name.as_str()).unwrap();
         let c_password = CString::new(role_creds.password.as_str()).unwrap();
         let mut server_connection_ptr: *mut CServerConnection = ptr::null_mut();
@@ -54,7 +67,12 @@ impl Server {
                 &mut server_connection_ptr,
             )
         }))?;
-        log::debug!("Established connection");
-        Ok(Connection::new(role_creds, server_connection_ptr))
+        if server_connection_ptr.is_null() {
+            log::error!("Could not establish connection to server");
+            Err(CouldNotConnectToServer)
+        } else {
+            log::debug!("Established connection to server");
+            Ok(ServerConnection::new(role_creds, server_connection_ptr))
+        }
     }
 }

Diff for: src/server.rs

@@ -12,22 +12,22 @@ use crate::{
         CServerConnection_getNumberOfThreads, CServerConnection_newDataStoreConnection,
         CServerConnection_setNumberOfThreads,
     },
-    DataStoreConnection, Error, RoleCreds,
+    DataStore, DataStoreConnection, Error, RoleCreds,
 };
 
-pub struct Connection {
+pub struct ServerConnection {
     #[allow(dead_code)]
     role_creds: RoleCreds,
     inner: *mut CServerConnection,
 }
 
-impl Drop for Connection {
+impl Drop for ServerConnection {
     fn drop(&mut self) {
         self.destroy()
     }
 }
 
-impl Connection {
+impl ServerConnection {
     pub(crate) fn new(
         role_creds: &RoleCreds,
         server_connection_ptr: *mut CServerConnection,
@@ -58,34 +58,35 @@ impl Connection {
         })
     }
 
-    pub fn create_data_store(&self, name: &str) -> Result<(), Error> {
-        log::debug!("Creating data store [{}]", name);
-        let c_name = CString::new(name).unwrap();
+    pub fn create_data_store(&self, data_store: DataStore) -> Result<DataStore, Error> {
+        log::debug!("Creating {data_store}");
+        let c_name = CString::new(data_store.name.as_str()).unwrap();
         CException::handle(|| unsafe {
             CServerConnection_createDataStore(
                 self.inner,
                 c_name.as_ptr(),
                 CParameters_getEmptyParameters(),
             )
         })?;
-        log::info!("Created data store [{}]", name);
-        Ok(())
+        log::info!("Created {data_store}");
+        Ok(data_store)
     }
 
-    pub fn connect_to_data_store(&self, name: &str) -> Result<DataStoreConnection, Error> {
-        log::debug!("Connecting to data store [{}]", name);
-        let mut ds_connection = DataStoreConnection {
-            inner: ptr::null_mut(),
-        };
-        let c_name = CString::new(name).unwrap();
+    pub fn connect_to_data_store(
+        &self,
+        data_store: DataStore,
+    ) -> Result<DataStoreConnection, Error> {
+        log::debug!("Connecting to {}", data_store);
+        let mut ds_connection = DataStoreConnection::new(data_store.clone(), ptr::null_mut());
+        let c_name = CString::new(data_store.name.as_str()).unwrap();
         CException::handle(AssertUnwindSafe(|| unsafe {
             CServerConnection_newDataStoreConnection(
                 self.inner,
                 c_name.as_ptr(),
                 &mut ds_connection.inner,
             )
         }))?;
-        log::debug!("Connected to data store [{}]", name);
+        log::debug!("Connected to {}", data_store);
         Ok(ds_connection)
     }
 

Diff for: src/server_connection.rs

@@ -31,6 +31,6 @@ impl<'a> Statement<'a> {
         connection: &DataStoreConnection,
         parameters: &Parameters,
     ) -> Result<Cursor, Error> {
-        Cursor::create(connection, parameters, self)
+        Cursor::create(connection, &parameters, &self)
     }
 }