Initialize synchronizers only once

Author: astonbitecode

src/asynch/dropbox.rs

@@ -79,6 +79,7 @@ lazy_static! {
 }
 
 /// A Dropbox synchronizer
+#[derive(Clone)]
 pub(crate) struct Synchronizer {
     /// The configuration needed for this synchronizer
     conf: DropboxConfiguration,
@@ -90,24 +91,21 @@ pub(crate) struct Synchronizer {
     version_local: Option<i64>,
     /// The version that was set during the last sync
     last_sync_version: Option<i64>,
-    /// The factory that creates HTTP clients
-    client_factory: Box<dyn RklHttpAsyncFactory<ClientResType = Vec<u8>>>,
 }
 
 impl Synchronizer {
     pub(crate) fn new(
         dbc: &DropboxConfiguration,
         sys_conf: &SystemConfiguration,
         f: &str,
-        client_factory: Box<dyn RklHttpAsyncFactory<ClientResType = Vec<u8>>>,
+        //client_factory: Box<dyn RklHttpAsyncFactory<ClientResType = Vec<u8>>>,
     ) -> errors::Result<Synchronizer> {
         let s = Synchronizer {
             conf: dbc.clone(),
             file_name: f.to_string(),
             saved_at_local: sys_conf.saved_at,
             version_local: sys_conf.version,
             last_sync_version: sys_conf.last_sync_version,
-            client_factory,
         };
         Ok(s)
     }
@@ -127,7 +125,8 @@ impl Synchronizer {
         let saved_at_local = self.saved_at_local.clone();
         let version_local = self.version_local.clone();
         let last_sync_version = self.last_sync_version.clone();
-        let mut client = self.client_factory.create();
+        let client_factory = Box::new(ReqwestClientFactory::new());
+        let mut client = client_factory.create();
         client.header(
             "Authorization",
             &format!("Bearer {}", self.use_short_lived_token()?.as_str()),
@@ -151,7 +150,8 @@ impl Synchronizer {
     }
 
     async fn get_short_lived_token(&self) -> errors::Result<Zeroizing<String>> {
-        let mut client = self.client_factory.create();
+        let client_factory = Box::new(ReqwestClientFactory::new());
+        let mut client = client_factory.create();
         debug!("DBX: Retrieving a short-lived token");
 
         let post_body: Vec<u8> = format!(

src/asynch/nextcloud.rs

@@ -41,6 +41,7 @@ lazy_static! {
 }
 
 /// A (Next/Own)cloud synchronizer
+#[derive(Clone)]
 pub(crate) struct Synchronizer {
     /// The configuration needed for this synchronizer
     conf: NextcloudConfiguration,

src/lib.rs

@@ -45,7 +45,7 @@ use std::time::Duration;
 
 pub use api::GeneralConfiguration;
 use async_trait::async_trait;
-use asynch::{AsyncTask, ReqwestClientFactory, SyncStatus};
+use asynch::{AsyncTask, SyncStatus};
 use futures::{future, select, FutureExt};
 use log::*;
 
@@ -143,6 +143,8 @@ struct CoreLogicHandler {
     // Keeps the sensitive data
     safe: Safe,
     configuration: RklConfiguration,
+    dbx_synchronizer: dropbox::Synchronizer,
+    nc_synchronizer: nextcloud::Synchronizer,
     // Signals changes that are not saved
     contents_changed: bool,
     cryptor: datacrypt::BcryptAes,
@@ -187,12 +189,30 @@ impl CoreLogicHandler {
             user_selection = us;
             cr
         };
+
+        // Initialize the synchronizers
+        let mut nc_synchronizer = nextcloud::Synchronizer::new(
+            &configuration.nextcloud, 
+            &configuration.system,
+                FILENAME
+            ).unwrap();
+        nc_synchronizer.init().await;
+
+        let mut dbx_synchronizer = dropbox::Synchronizer::new(
+            &configuration.dropbox, 
+            &configuration.system,
+                FILENAME
+            ).unwrap();
+        dbx_synchronizer.init().await;
+        
         CoreLogicHandler {
             editor,
             props: props,
             user_selection,
             safe,
             configuration,
+            dbx_synchronizer,
+            nc_synchronizer,
             contents_changed,
             cryptor,
         }
@@ -788,25 +808,11 @@ Warning: Saving will discard all the entries that could not be recovered.
             }
         };
 
-        // Initialize the synchronizers
-        let mut nc_synchronizer = nextcloud::Synchronizer::new(
-            &s.configuration.nextcloud, 
-            &s.configuration.system,
-                FILENAME
-            ).unwrap();
-        nc_synchronizer.init().await;
-
-        let mut dbx_synchronizer = dropbox::Synchronizer::new(
-            &s.configuration.dropbox, 
-            &s.configuration.system,
-                FILENAME,
-                Box::new(ReqwestClientFactory::new())
-            ).unwrap();
-        dbx_synchronizer.init().await;
-
         // Prepare all the possible futures from which we expect possible user_selection
-        let mut nc_future = nc_synchronizer.execute().fuse();
-        let mut dbx_future = dbx_synchronizer.execute().fuse();
+        let nc_synchronizer_clonne = s.nc_synchronizer.clone();
+        let dbx_synchronizer_clone = s.dbx_synchronizer.clone();
+        let mut nc_future = nc_synchronizer_clonne.execute().fuse();
+        let mut dbx_future = dbx_synchronizer_clone.execute().fuse();
         let mut fused_user_selection_future = user_selection_future.fuse();
         let mut inactivity_timeout_future = Box::pin(sleep(Duration::from_secs(s.props.idle_timeout_seconds() as u64))).fuse();