Make cursor broadcast configurable

backend/sync_server/Cargo.toml

@@ -38,6 +38,7 @@ serde_json = "1.0.140"
 clap-verbosity-flag = "3.0.3"
 bimap = "0.6.3"
 ts-rs =  { version = "10.1", features = ["uuid-impl", "chrono-impl"] }
+serde_with = "3.12.0"
 
 [lints]
 workspace = true

backend/sync_server/src/app_state/cursors.rs

@@ -1,8 +1,6 @@
 use core::time::Duration;
 use std::{collections::HashMap, sync::Arc};
 
-use chrono::TimeDelta;
-use sqlx::types::chrono::Utc;
 use tokio::sync::Mutex;
 
 use super::{
@@ -10,15 +8,13 @@ use super::{
     websocket::{
         broadcasts::Broadcasts,
         models::{
-            ClientCursors, CursorPositionFromServer, WebSocketServerMessage,
+            ClientCursors, CursorPositionFromServer, CursorSpan, WebSocketServerMessage,
             WebSocketServerMessageWithOrigin,
         },
     },
 };
 use crate::config::database_config::DatabaseConfig;
 
-const BACKGROUND_TASK_INTERVAL: Duration = Duration::from_secs(1);
-
 #[derive(Clone, Debug)]
 pub struct Cursors {
     config: DatabaseConfig,
@@ -39,7 +35,7 @@ impl Cursors {
         &self,
         vault_id: VaultId,
         device_id: &DeviceId,
-        document_to_cursors: HashMap<String, Vec<usize>>,
+        document_to_cursors: HashMap<String, Vec<CursorSpan>>,
     ) {
         let mut vault_to_cursors = self.vault_to_cursors.lock().await;
 
@@ -76,7 +72,7 @@ impl Cursors {
         loop {
             self.remove_expired_cursors().await;
             self.broadcast_cursors().await;
-            tokio::time::sleep(BACKGROUND_TASK_INTERVAL).await;
+            tokio::time::sleep(self.config.cursor_broadcast_interval).await;
         }
     }
 
@@ -109,16 +105,16 @@ impl Cursors {
 #[derive(Clone, Debug)]
 struct ClientCursorsWithTimeToLive {
     client_cursors: ClientCursors,
-    last_updated: chrono::DateTime<Utc>,
+    last_updated: std::time::Instant,
 }
 
 impl ClientCursorsWithTimeToLive {
     fn new(client_cursors: ClientCursors) -> Self {
         Self {
             client_cursors,
-            last_updated: Utc::now(),
+            last_updated: std::time::Instant::now(),
         }
     }
 
-    pub fn is_expired(&self, ttl: TimeDelta) -> bool { Utc::now() - self.last_updated > ttl }
+    pub fn is_expired(&self, ttl: Duration) -> bool { self.last_updated.elapsed() > ttl }
 }

backend/sync_server/src/config/database_config.rs

@@ -1,13 +1,15 @@
-use std::path::PathBuf;
+use std::{path::PathBuf, time::Duration};
 
-use chrono::TimeDelta;
 use log::debug;
 use serde::{Deserialize, Serialize};
+use serde_with::serde_as;
 
 use crate::consts::{
-    DEFAULT_CURSOR_TIMEOUT, DEFAULT_DATABASES_DIRECTORY_PATH, DEFAULT_MAX_CONNECTIONS_PER_VAULT,
+    DEFAULT_CURSOR_BROADCAST_INTERVAL, DEFAULT_CURSOR_TIMEOUT, DEFAULT_DATABASES_DIRECTORY_PATH,
+    DEFAULT_MAX_CONNECTIONS_PER_VAULT,
 };
 
+#[serde_with::serde_as]
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct DatabaseConfig {
     #[serde(default = "default_databases_directory_path")]
@@ -16,8 +18,16 @@ pub struct DatabaseConfig {
     #[serde(default = "default_max_connections_per_vault")]
     pub max_connections_per_vault: u32,
 
-    #[serde(default = "default_cursor_timeout")]
-    pub cursor_timeout: TimeDelta,
+    #[serde(default = "default_cursor_timeout", rename = "cursor_timeout_seconds")]
+    #[serde_as(as = "serde_with::DurationSeconds<u64>")]
+    pub cursor_timeout: Duration,
+
+    #[serde(
+        default = "default_cursor_broadcast_interval",
+        rename = "cursor_broadcast_interval_seconds"
+    )]
+    #[serde_as(as = "serde_with::DurationSeconds<u64>")]
+    pub cursor_broadcast_interval: Duration,
 }
 
 fn default_databases_directory_path() -> PathBuf {
@@ -30,17 +40,23 @@ fn default_max_connections_per_vault() -> u32 {
     DEFAULT_MAX_CONNECTIONS_PER_VAULT
 }
 
-fn default_cursor_timeout() -> TimeDelta {
-    debug!("Using default cursor timeout: {DEFAULT_CURSOR_TIMEOUT}");
+fn default_cursor_timeout() -> Duration {
+    debug!("Using default cursor timeout: {DEFAULT_CURSOR_TIMEOUT:?}");
     DEFAULT_CURSOR_TIMEOUT
 }
 
+fn default_cursor_broadcast_interval() -> Duration {
+    debug!("Using default cursor broadcast interval: {DEFAULT_CURSOR_BROADCAST_INTERVAL:?}");
+    DEFAULT_CURSOR_BROADCAST_INTERVAL
+}
+
 impl Default for DatabaseConfig {
     fn default() -> Self {
         Self {
             databases_directory_path: default_databases_directory_path(),
             max_connections_per_vault: default_max_connections_per_vault(),
             cursor_timeout: default_cursor_timeout(),
+            cursor_broadcast_interval: default_cursor_broadcast_interval(),
         }
     }
 }

backend/sync_server/src/consts.rs

@@ -1,10 +1,11 @@
-use chrono::TimeDelta;
+use std::time::Duration;
 
 pub const DEFAULT_CONFIG_PATH: &str = "config.yml";
 
 pub const DEFAULT_DATABASES_DIRECTORY_PATH: &str = "databases";
 pub const DEFAULT_MAX_CONNECTIONS_PER_VAULT: u32 = 12;
-pub const DEFAULT_CURSOR_TIMEOUT: TimeDelta = TimeDelta::seconds(60);
+pub const DEFAULT_CURSOR_TIMEOUT: Duration = Duration::from_secs(60);
+pub const DEFAULT_CURSOR_BROADCAST_INTERVAL: Duration = Duration::from_secs(1);
 
 pub const DEFAULT_HOST: &str = "127.0.0.1";
 pub const DEFAULT_PORT: u16 = 3000;