Skip to main content

absurder_sql/storage/
sync_operations.rs

1//! Sync operations for BlockStorage
2//! This module contains the core sync implementation logic
3
4// Reentrancy-safe lock macros
5#[cfg(target_arch = "wasm32")]
6macro_rules! lock_mutex {
7    ($mutex:expr) => {
8        $mutex
9            .try_borrow_mut()
10            .expect("RefCell borrow failed - reentrancy detected in sync_operations.rs")
11    };
12}
13
14#[cfg(not(target_arch = "wasm32"))]
15macro_rules! lock_mutex {
16    ($mutex:expr) => {
17        $mutex.lock()
18    };
19}
20
21#[allow(unused_macros)]
22#[cfg(target_arch = "wasm32")]
23macro_rules! try_lock_mutex {
24    ($mutex:expr) => {
25        $mutex
26    };
27}
28
29#[allow(unused_macros)]
30#[cfg(not(target_arch = "wasm32"))]
31macro_rules! try_lock_mutex {
32    ($mutex:expr) => {
33        $mutex.lock()
34    };
35}
36
37use super::block_storage::BlockStorage;
38use crate::types::DatabaseError;
39
40#[cfg(all(not(target_arch = "wasm32"), not(feature = "fs_persist")))]
41use std::collections::HashMap;
42#[cfg(all(not(target_arch = "wasm32"), not(feature = "fs_persist")))]
43use std::sync::atomic::Ordering;
44
45#[cfg(any(
46    target_arch = "wasm32",
47    all(not(target_arch = "wasm32"), not(feature = "fs_persist"))
48))]
49use super::metadata::BlockMetadataPersist;
50#[cfg(any(
51    target_arch = "wasm32",
52    all(not(target_arch = "wasm32"), not(feature = "fs_persist"))
53))]
54use super::vfs_sync;
55
56#[cfg(target_arch = "wasm32")]
57use std::collections::HashMap;
58
59#[cfg(all(not(target_arch = "wasm32"), not(feature = "fs_persist")))]
60use super::block_storage::GLOBAL_METADATA_TEST;
61
62/// Internal sync implementation shared by sync() and sync_now()
63pub fn sync_implementation_impl(storage: &mut BlockStorage) -> Result<(), DatabaseError> {
64    #[cfg(all(not(target_arch = "wasm32"), not(feature = "fs_persist")))]
65    let start = std::time::Instant::now();
66
67    let dirty_count = lock_mutex!(storage.dirty_blocks).len();
68    let dirty_bytes = dirty_count * super::block_storage::BLOCK_SIZE;
69    storage
70        .observability
71        .record_sync_start(dirty_count, dirty_bytes);
72
73    #[cfg(not(target_arch = "wasm32"))]
74    if let Some(ref callback) = storage.observability.sync_start_callback {
75        callback(dirty_count, dirty_bytes);
76    }
77
78    #[cfg(all(not(target_arch = "wasm32"), feature = "fs_persist"))]
79    {
80        storage.fs_persist_sync()
81    }
82
83    #[cfg(all(not(target_arch = "wasm32"), not(feature = "fs_persist")))]
84    {
85        let current_dirty = lock_mutex!(storage.dirty_blocks).len();
86        log::info!(
87            "Syncing {} dirty blocks (native non-fs_persist)",
88            current_dirty
89        );
90
91        let to_persist: Vec<(u64, Vec<u8>)> = {
92            let dirty = lock_mutex!(storage.dirty_blocks);
93            dirty.iter().map(|(k, v)| (*k, v.clone())).collect()
94        };
95        let ids: Vec<u64> = to_persist.iter().map(|(k, _)| *k).collect();
96        let blocks_synced = ids.len();
97
98        let next_commit: u64 = vfs_sync::with_global_commit_marker(|cm| {
99            let cm = cm.borrow();
100            let current = cm.get(&storage.db_name).copied().unwrap_or(0);
101            current + 1
102        });
103
104        vfs_sync::with_global_storage(|gs| {
105            let mut storage_map = gs.borrow_mut();
106            let db_storage = storage_map
107                .entry(storage.db_name.clone())
108                .or_insert_with(HashMap::new);
109            for (block_id, data) in to_persist {
110                db_storage.insert(block_id, data);
111            }
112        });
113
114        GLOBAL_METADATA_TEST.with(|meta| {
115            let mut meta_map = meta.lock();
116            let db_meta = meta_map
117                .entry(storage.db_name.clone())
118                .or_insert_with(HashMap::new);
119            for block_id in ids {
120                if let Some(checksum) = storage.checksum_manager.get_checksum(block_id) {
121                    db_meta.insert(
122                        block_id,
123                        BlockMetadataPersist {
124                            checksum,
125                            last_modified_ms: std::time::SystemTime::now()
126                                .duration_since(std::time::UNIX_EPOCH)
127                                .unwrap_or_default()
128                                .as_millis() as u64,
129                            version: next_commit as u32,
130                            algo: storage.checksum_manager.get_algorithm(block_id),
131                        },
132                    );
133                }
134            }
135        });
136
137        vfs_sync::with_global_commit_marker(|cm| {
138            let mut cm_map = cm.borrow_mut();
139            cm_map.insert(storage.db_name.clone(), next_commit);
140        });
141
142        lock_mutex!(storage.dirty_blocks).clear();
143
144        storage.sync_count.fetch_add(1, Ordering::SeqCst);
145        let ms = (start.elapsed().as_millis() as u64).max(1);
146        storage.last_sync_duration_ms.store(ms, Ordering::SeqCst);
147        storage.observability.record_sync_success(ms, blocks_synced);
148
149        if let Some(ref callback) = storage.observability.sync_success_callback {
150            callback(ms, blocks_synced);
151        }
152
153        storage.evict_if_needed();
154        return Ok(());
155    }
156
157    #[cfg(target_arch = "wasm32")]
158    {
159        let current_dirty = lock_mutex!(storage.dirty_blocks).len();
160        log::info!("Syncing {} dirty blocks (WASM)", current_dirty);
161
162        let to_persist: Vec<(u64, Vec<u8>)> = {
163            let dirty = lock_mutex!(storage.dirty_blocks);
164            dirty.iter().map(|(k, v)| (*k, v.clone())).collect()
165        };
166        let ids: Vec<u64> = to_persist.iter().map(|(k, _)| *k).collect();
167        let next_commit: u64 = vfs_sync::with_global_commit_marker(|cm| {
168            let current = cm.borrow().get(&storage.db_name).copied().unwrap_or(0);
169            current + 1
170        });
171        let metadata_to_persist: Vec<(u64, BlockMetadataPersist)> = ids
172            .iter()
173            .filter_map(|block_id| {
174                storage
175                    .checksum_manager
176                    .get_checksum(*block_id)
177                    .map(|checksum| {
178                        (
179                            *block_id,
180                            BlockMetadataPersist {
181                                checksum,
182                                last_modified_ms: BlockStorage::now_millis(),
183                                version: next_commit as u32,
184                                algo: storage.checksum_manager.get_algorithm(*block_id),
185                            },
186                        )
187                    })
188            })
189            .collect();
190
191        vfs_sync::with_global_storage(|gs| {
192            let mut storage_map = gs.borrow_mut();
193            let db_storage = storage_map
194                .entry(storage.db_name.clone())
195                .or_insert_with(HashMap::new);
196            for (block_id, data) in &to_persist {
197                let should_update = if let Some(existing) = db_storage.get(block_id) {
198                    if existing != data {
199                        !vfs_sync::with_global_metadata(|meta| {
200                            meta.borrow()
201                                .get(&storage.db_name)
202                                .and_then(|db_meta| db_meta.get(block_id))
203                                .is_some_and(|metadata| metadata.version > 0)
204                        })
205                    } else {
206                        true
207                    }
208                } else {
209                    true
210                };
211
212                if should_update {
213                    db_storage.insert(*block_id, data.clone());
214                }
215            }
216        });
217
218        vfs_sync::with_global_metadata(|meta| {
219            let mut meta_guard = meta.borrow_mut();
220            let db_meta = meta_guard
221                .entry(storage.db_name.clone())
222                .or_insert_with(HashMap::new);
223            for (block_id, metadata) in &metadata_to_persist {
224                db_meta.insert(*block_id, metadata.clone());
225            }
226        });
227        vfs_sync::with_global_commit_marker(|cm| {
228            cm.borrow_mut().insert(storage.db_name.clone(), next_commit);
229        });
230
231        if !to_persist.is_empty() {
232            let db_name = storage.db_name.clone();
233            let backend = storage.storage_backend();
234            wasm_bindgen_futures::spawn_local(async move {
235                let persist_result = match backend {
236                    super::block_storage::StorageBackend::IndexedDb => {
237                        super::wasm_indexeddb::persist_to_indexeddb_event_based(
238                            &db_name,
239                            to_persist,
240                            metadata_to_persist,
241                            next_commit,
242                            #[cfg(feature = "telemetry")]
243                            None,
244                            #[cfg(feature = "telemetry")]
245                            None,
246                        )
247                        .await
248                    }
249                    super::block_storage::StorageBackend::Opfs
250                    | super::block_storage::StorageBackend::Hybrid => {
251                        super::hybrid_store::hybrid_persist(
252                            &db_name,
253                            to_persist,
254                            metadata_to_persist,
255                            next_commit,
256                            #[cfg(feature = "telemetry")]
257                            None,
258                            #[cfg(feature = "telemetry")]
259                            None,
260                        )
261                        .await
262                    }
263                };
264
265                if let Err(error) = persist_result {
266                    log::error!(
267                        "Failed to persist {} using backend {}: {}",
268                        db_name,
269                        backend.as_str(),
270                        error
271                    );
272                }
273            });
274        }
275
276        lock_mutex!(storage.dirty_blocks).clear();
277        storage.observability.record_sync_success(1, current_dirty);
278
279        if let Some(ref callback) = storage.observability.wasm_sync_success_callback {
280            callback(1, current_dirty);
281        }
282
283        storage.evict_if_needed();
284        Ok(())
285    }
286}