Change the sync heuristics

we use the following heuristic to determine if we need to sync the db file
1. if no db file or the metadata file exists, then user is starting from scratch
and we will do the sync
2. if the db file exists, but the metadata file does not exist (or other way around),
then local db is in an incorrect state. we stop and return with an error
3. if the db file exists and the metadata file exists, then we don't need to do the
sync

Author: avinassh

libsql/src/sync.rs

@@ -64,6 +64,8 @@ pub enum SyncError {
     PullDb(StatusCode, String),
     #[error("server returned a lower generation than local: local={0}, remote={1}")]
     InvalidLocalGeneration(u32, u32),
+    #[error("invalid local state: {0}")]
+    InvalidLocalState(String),
 }
 
 impl SyncError {
@@ -509,27 +511,60 @@ impl SyncContext {
     }
 
     async fn sync_db_if_needed(&mut self, generation: u32) -> Result<()> {
-        // we will get the export file only if the remote generation is different from the one we have
-        if generation == self.durable_generation {
-            return Ok(());
-        }
         // somehow we are ahead of the remote in generations. following should not happen because
         // we checkpoint only if the remote server tells us to do so.
         if self.durable_generation > generation {
             tracing::error!(
-                "server returned a lower generation than what we have: sent={}, got={}",
+                "server returned a lower generation than what we have: local={}, remote={}",
                 self.durable_generation,
                 generation
             );
             return Err(
                 SyncError::InvalidLocalGeneration(self.durable_generation, generation).into(),
             );
         }
-        tracing::debug!(
-            "syncing db file from remote server, generation={}",
-            generation
-        );
-        self.sync_db(generation).await
+        // we use the following heuristic to determine if we need to sync the db file
+        // 1. if no db file or the metadata file exists, then user is starting from scratch
+        //    and we will do the sync
+        // 2. if the db file exists, but the metadata file does not exist (or other way around),
+        //    then local db is in an incorrect state. we stop and return with an error
+        // 3. if the db file exists and the metadata file exists, then we don't need to do the
+        //    sync
+        let metadata_exists = check_if_file_exists(&format!("{}-info", self.db_path))?;
+        let db_file_exists = check_if_file_exists(&self.db_path)?;
+        match (metadata_exists, db_file_exists) {
+            (false, false) => {
+                tracing::debug!(
+                    "syncing db file from remote server, generation={}",
+                    generation
+                );
+                self.sync_db(generation).await
+            }
+            (false, true) => {
+                // inconsistent state: DB exists but metadata missing
+                tracing::error!(
+                    "local state is incorrect, db file exists but metadata file does not"
+                );
+                Err(SyncError::InvalidLocalState(
+                    "db file exists but metadata file does not".to_string(),
+                )
+                .into())
+            }
+            (true, false) => {
+                // inconsistent state: Metadata exists but DB missing
+                tracing::error!(
+                    "local state is incorrect, metadata file exists but db file does not"
+                );
+                Err(SyncError::InvalidLocalState(
+                    "metadata file exists but db file does not".to_string(),
+                )
+                .into())
+            }
+            (true, true) => {
+                // both files exists, need to sync
+                Ok(())
+            }
+        }
     }
 
     /// sync_db will download the db file from the remote server and replace the local file.
@@ -831,3 +866,9 @@ async fn try_pull(
         })
     }
 }
+
+fn check_if_file_exists(path: &str) -> core::result::Result<bool, SyncError> {
+    Path::new(&path)
+        .try_exists()
+        .map_err(SyncError::io("metadata file exists"))
+}