Feat: max_retries as env config var

.env-sample

@@ -19,6 +19,8 @@ HOMESERVER_URL=http://localhost:6287
 EVENTS_LIMIT=1000
 # Sleep between checks to homeserver
 WATCHER_SLEEP=5000
+# Max amount of event retries
+MAX_RETRIES=1
 
 # Directory where static files are stored
 STATIC_PATH=./static

src/config.rs

@@ -21,6 +21,7 @@ pub struct Config {
     pub homeserver_url: String,
     pub events_limit: u32,
     pub watcher_sleep: u64,
+    pub max_retries: u64,
 }
 
 impl Config {
@@ -57,6 +58,10 @@ impl Config {
                 .unwrap_or("5000".to_string())
                 .parse()
                 .unwrap_or(5000),
+            max_retries: env::var("MAX_RETRIES")
+                .unwrap_or("1".to_string())
+                .parse()
+                .unwrap_or(1),
             neo4j_username: env::var("NEO4J_DB_USERNAME").expect("NEO4J_DB_USERNAME not set"),
             neo4j_password: env::var("NEO4J_PASSWORD").expect("NEO4J_PASSWORD not set"),
         }

src/events/processor.rs

@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 use super::Event;
 use crate::{
     models::{homeserver::Homeserver, user::PubkyId},
@@ -8,13 +10,12 @@ use pkarr::mainline::dht::Testnet;
 use pubky::PubkyClient;
 use reqwest::Client;
 
-const MAX_RETRIES: usize = 3;
-
 pub struct EventProcessor {
     pubky_client: PubkyClient,
     http_client: Client,
     homeserver: Homeserver,
     limit: u32,
+    max_retries: u64,
 }
 
 impl EventProcessor {
@@ -24,6 +25,7 @@ impl EventProcessor {
         let pubky_client = Self::init_pubky_client(config);
         let homeserver = Homeserver::from_config(config).await?;
         let limit = config.events_limit;
+        let max_retries = config.max_retries;
 
         info!(
             "Initialized Event Processor for homeserver: {:?}",
@@ -35,6 +37,7 @@ impl EventProcessor {
             http_client: Client::new(),
             homeserver,
             limit,
+            max_retries,
         })
     }
 
@@ -58,6 +61,7 @@ impl EventProcessor {
             http_client: Client::new(),
             homeserver,
             limit: 100,
+            max_retries: 3,
         }
     }
 
@@ -124,7 +128,7 @@ impl EventProcessor {
                 Ok(_) => break Ok(()),
                 Err(e) => {
                     attempts += 1;
-                    if attempts >= MAX_RETRIES {
+                    if attempts >= self.max_retries {
                         error!(
                             "Error while handling event after {} attempts: {}",
                             attempts, e
@@ -133,10 +137,10 @@ impl EventProcessor {
                     } else {
                         error!(
                             "Error while handling event: {}. Retrying attempt {}/{}",
-                            e, attempts, MAX_RETRIES
+                            e, attempts, self.max_retries
                         );
                         // Optionally, add a delay between retries
-                        // tokio::time::sleep(Duration::from_millis(100)).await;
+                        tokio::time::sleep(Duration::from_millis(100)).await;
                     }
                 }
             }