Merge branch 'feat/storage' into 'master'

Core: expose cache_path

See merge request TankerHQ/sdk-rust!89

Author: blastrock

src/core.rs

@@ -21,8 +21,9 @@ impl Core {
     /// # use tankersdk::*;
     /// # async {
     /// let app_id = "Your tanker App ID".to_string();
-    /// let writable_path = "/some/writable/path".to_string();
-    /// let tanker = Core::new(Options::new(app_id, writable_path)).await?;
+    /// let persistent_path = "/some/writable/path".to_string();
+    /// let cache_path = "/some/cache/path".to_string();
+    /// let tanker = Core::new(Options::new(app_id, persistent_path, cache_path)).await?;
     /// # Result::<(), Error>::Ok(()) };
     /// ```
     pub async fn new(options: Options) -> Result<Self, Error> {

src/ctanker.rs

@@ -151,19 +151,31 @@ impl CTankerLib {
 
         let fut = {
             let coptions = tanker_options {
-                version: 3,
+                version: 4,
                 app_id: options.app_id.as_ptr(),
                 url: options
                     .url
                     .as_ref()
                     .map(|s| s.as_ptr())
                     .unwrap_or(std::ptr::null()),
-                writable_path: options.writable_path.as_ptr(),
+                persistent_path: options.persistent_path.as_ptr(),
+                cache_path: options.cache_path.as_ptr(),
                 sdk_type: sdk_type.as_ptr(),
                 sdk_version: sdk_version.as_ptr(),
-                http_send_request: None,
-                http_cancel_request: None,
-                http_data: std::ptr::null_mut(),
+                http_options: tanker_http_options {
+                    send_request: None,
+                    cancel_request: None,
+                    data: std::ptr::null_mut(),
+                },
+                datastore_options: tanker_datastore_options {
+                    open: None,
+                    close: None,
+                    nuke: None,
+                    put_serialized_device: None,
+                    find_serialized_device: None,
+                    put_cache_values: None,
+                    find_cache_values: None,
+                },
             };
             unsafe { CFuture::new(tanker_call!(self, tanker_create(&coptions))) }
         };

src/types.rs

@@ -10,20 +10,24 @@ use std::fmt::{Display, Formatter};
 pub struct Options {
     pub(crate) url: Option<CString>,
     pub(crate) app_id: CString,
-    pub(crate) writable_path: CString,
+    pub(crate) persistent_path: CString,
+    pub(crate) cache_path: CString,
     pub(crate) sdk_type: Option<CString>,
 }
 
 impl Options {
     /// # Arguments
     /// * `app_id` - Your Tanker App ID
-    /// * `writable_path` - A writable folder. Tanker will use this folder to
+    /// * `persistent_path` - A writable folder. Tanker will use this folder to
     ///    store persistent data about user sessions on the current device.
-    pub fn new(app_id: String, writable_path: String) -> Self {
+    /// * `cache_path` - A writable folder. Tanker will use this folder to
+    ///    store encrypted cached keys. May be the same as `persistent_path`.
+    pub fn new(app_id: String, persistent_path: String, cache_path: String) -> Self {
         Self {
             url: None,
             app_id: CString::new(app_id).unwrap(),
-            writable_path: CString::new(writable_path).unwrap(),
+            persistent_path: CString::new(persistent_path).unwrap(),
+            cache_path: CString::new(cache_path).unwrap(),
             sdk_type: None,
         }
     }

tests/identity/test_app.rs

@@ -31,9 +31,13 @@ impl TestApp {
     }
 
     pub fn make_options(&self) -> Options {
-        Options::new(self.id().to_owned(), ":memory:".to_owned())
-            .with_url(self.config.api_url.clone())
-            .with_sdk_type("sdk-rust-test".to_string())
+        Options::new(
+            self.id().to_owned(),
+            ":memory:".to_owned(),
+            ":memory:".to_string(),
+        )
+        .with_url(self.config.api_url.clone())
+        .with_sdk_type("sdk-rust-test".to_string())
     }
 
     async fn new() -> Self {

tests/tanker_tests.rs

@@ -16,17 +16,25 @@ fn core_native_version() {
 #[tokio::test(flavor = "multi_thread")]
 async fn tanker_create() -> Result<(), Error> {
     let app = TestApp::get().await;
-    let opts = Options::new(app.id().to_owned(), ":memory:".to_string())
-        .with_sdk_type("sdk-rust-test".to_string());
+    let opts = Options::new(
+        app.id().to_owned(),
+        ":memory:".to_string(),
+        ":memory:".to_string(),
+    )
+    .with_sdk_type("sdk-rust-test".to_string());
     let core = Core::new(opts).await?;
     drop(core);
     Ok(())
 }
 
 #[tokio::test(flavor = "multi_thread")]
 async fn tanker_bad_create() {
-    let opts = Options::new("bad-app-id".to_string(), ":memory:".to_string())
-        .with_sdk_type("sdk-rust-test".to_string());
+    let opts = Options::new(
+        "bad-app-id".to_string(),
+        ":memory:".to_string(),
+        ":memory:".to_string(),
+    )
+    .with_sdk_type("sdk-rust-test".to_string());
     let err = Core::new(opts)
         .await
         .expect_err("The app ID should not be accepted, it's not valid base64");