Add libsql_open_sync_with_config (#1566)

Bindings: Add libsql_open_sync_with_config

Signed-off-by: Piotr Jastrzebski <[email protected]>

Author: haaawk

bindings/c/include/libsql.h

@@ -27,6 +27,16 @@ typedef struct libsql_stmt libsql_stmt;
 
 typedef const libsql_database *libsql_database_t;
 
+typedef struct {
+  const char *db_path;
+  const char *primary_url;
+  const char *auth_token;
+  char read_your_writes;
+  const char *encryption_key;
+  int sync_interval;
+  char with_webpki;
+} libsql_config;
+
 typedef const libsql_connection *libsql_connection_t;
 
 typedef const libsql_stmt *libsql_stmt_t;
@@ -64,6 +74,8 @@ int libsql_open_sync_with_webpki(const char *db_path,
                                  libsql_database_t *out_db,
                                  const char **out_err_msg);
 
+int libsql_open_sync_with_config(libsql_config config, libsql_database_t *out_db, const char **out_err_msg);
+
 int libsql_open_ext(const char *url, libsql_database_t *out_db, const char **out_err_msg);
 
 int libsql_open_file(const char *url, libsql_database_t *out_db, const char **out_err_msg);

bindings/c/src/lib.rs

@@ -5,6 +5,7 @@ extern crate lazy_static;
 
 mod types;
 
+use crate::types::libsql_config;
 use tokio::runtime::Runtime;
 use types::{
     blob, libsql_connection, libsql_connection_t, libsql_database, libsql_database_t, libsql_row,
@@ -54,16 +55,16 @@ pub unsafe extern "C" fn libsql_open_sync(
     out_db: *mut libsql_database_t,
     out_err_msg: *mut *const std::ffi::c_char,
 ) -> std::ffi::c_int {
-    libsql_open_sync_internal(
+    let config = libsql_config {
         db_path,
         primary_url,
         auth_token,
         read_your_writes,
         encryption_key,
-        false,
-        out_db,
-        out_err_msg,
-    )
+        sync_interval: 0,
+        with_webpki: 0,
+    };
+    libsql_open_sync_with_config(config, out_db, out_err_msg)
 }
 
 #[no_mangle]
@@ -76,45 +77,41 @@ pub unsafe extern "C" fn libsql_open_sync_with_webpki(
     out_db: *mut libsql_database_t,
     out_err_msg: *mut *const std::ffi::c_char,
 ) -> std::ffi::c_int {
-    libsql_open_sync_internal(
+    let config = libsql_config {
         db_path,
         primary_url,
         auth_token,
         read_your_writes,
         encryption_key,
-        true,
-        out_db,
-        out_err_msg,
-    )
+        sync_interval: 0,
+        with_webpki: 1,
+    };
+    libsql_open_sync_with_config(config, out_db, out_err_msg)
 }
 
-unsafe fn libsql_open_sync_internal(
-    db_path: *const std::ffi::c_char,
-    primary_url: *const std::ffi::c_char,
-    auth_token: *const std::ffi::c_char,
-    read_your_writes: std::ffi::c_char,
-    encryption_key: *const std::ffi::c_char,
-    with_webpki: bool,
+#[no_mangle]
+pub unsafe extern "C" fn libsql_open_sync_with_config(
+    config: libsql_config,
     out_db: *mut libsql_database_t,
     out_err_msg: *mut *const std::ffi::c_char,
 ) -> std::ffi::c_int {
-    let db_path = unsafe { std::ffi::CStr::from_ptr(db_path) };
+    let db_path = unsafe { std::ffi::CStr::from_ptr(config.db_path) };
     let db_path = match db_path.to_str() {
         Ok(url) => url,
         Err(e) => {
             set_err_msg(format!("Wrong URL: {e}"), out_err_msg);
             return 1;
         }
     };
-    let primary_url = unsafe { std::ffi::CStr::from_ptr(primary_url) };
+    let primary_url = unsafe { std::ffi::CStr::from_ptr(config.primary_url) };
     let primary_url = match primary_url.to_str() {
         Ok(url) => url,
         Err(e) => {
             set_err_msg(format!("Wrong URL: {e}"), out_err_msg);
             return 2;
         }
     };
-    let auth_token = unsafe { std::ffi::CStr::from_ptr(auth_token) };
+    let auth_token = unsafe { std::ffi::CStr::from_ptr(config.auth_token) };
     let auth_token = match auth_token.to_str() {
         Ok(token) => token,
         Err(e) => {
@@ -127,29 +124,37 @@ unsafe fn libsql_open_sync_internal(
         primary_url.to_string(),
         auth_token.to_string(),
     );
-    if with_webpki {
+    if config.with_webpki != 0 {
         let https = hyper_rustls::HttpsConnectorBuilder::new()
             .with_webpki_roots()
             .https_or_http()
             .enable_http1()
             .build();
         builder = builder.connector(https);
     }
-    let builder = builder.read_your_writes(read_your_writes != 0);
-    let builder = if encryption_key.is_null() {
-        builder
-    } else {
-        let key = unsafe { std::ffi::CStr::from_ptr(encryption_key) };
+    if config.sync_interval > 0 {
+        let interval = match config.sync_interval.try_into() {
+            Ok(d) => d,
+            Err(e) => {
+                set_err_msg(format!("Wrong periodic sync interval: {e}"), out_err_msg);
+                return 4;
+            }
+        };
+        builder = builder.sync_interval(std::time::Duration::from_secs(interval));
+    }
+    builder = builder.read_your_writes(config.read_your_writes != 0);
+    if !config.encryption_key.is_null() {
+        let key = unsafe { std::ffi::CStr::from_ptr(config.encryption_key) };
         let key = match key.to_str() {
             Ok(k) => k,
             Err(e) => {
                 set_err_msg(format!("Wrong encryption key: {e}"), out_err_msg);
-                return 4;
+                return 5;
             }
         };
         let key = bytes::Bytes::copy_from_slice(key.as_bytes());
         let config = libsql::EncryptionConfig::new(libsql::Cipher::Aes256Cbc, key);
-        builder.encryption_config(config)
+        builder = builder.encryption_config(config)
     };
     match RT.block_on(builder.build()) {
         Ok(db) => {
@@ -162,7 +167,7 @@ unsafe fn libsql_open_sync_internal(
                 format!("Error opening db path {db_path}, primary url {primary_url}: {e}"),
                 out_err_msg,
             );
-            5
+            6
         }
     }
 }

bindings/c/src/types.rs

@@ -4,6 +4,18 @@ pub const LIBSQL_TEXT: i8 = 3;
 pub const LIBSQL_BLOB: i8 = 4;
 pub const LIBSQL_NULL: i8 = 5;
 
+#[derive(Clone, Debug)]
+#[repr(C)]
+pub struct libsql_config {
+    pub db_path: *const std::ffi::c_char,
+    pub primary_url: *const std::ffi::c_char,
+    pub auth_token: *const std::ffi::c_char,
+    pub read_your_writes: std::ffi::c_char,
+    pub encryption_key: *const std::ffi::c_char,
+    pub sync_interval: std::ffi::c_int,
+    pub with_webpki: std::ffi::c_char,
+}
+
 #[derive(Clone, Debug)]
 #[repr(C)]
 pub struct blob {