implement list reload method; reload list on enable request

src/main.rs

@@ -34,7 +34,16 @@ async fn api_list_enable(
     rules: &State<Arc<RwLock<Rules>>>,
 ) -> Result<Json<Option<bool>>, Status> {
     Ok(Json(
-        rules.write().await.set_enabled(alias, true).map(|old| !old),
+        rules
+            .write()
+            .await
+            .set_enabled(alias, true)
+            .await
+            .map_err(|err| {
+                error!("List status change error: `{err}`");
+                Status::InternalServerError
+            })?
+            .map(|old| !old),
     ))
 }
 
@@ -43,7 +52,17 @@ async fn api_list_disable(
     alias: &str,
     rules: &State<Arc<RwLock<Rules>>>,
 ) -> Result<Json<Option<bool>>, Status> {
-    Ok(Json(rules.write().await.set_enabled(alias, false)))
+    Ok(Json(
+        rules
+            .write()
+            .await
+            .set_enabled(alias, false)
+            .await
+            .map_err(|err| {
+                error!("List status change error: `{err}`");
+                Status::InternalServerError
+            })?,
+    ))
 }
 
 #[rocket::launch]

src/rules.rs

@@ -17,10 +17,11 @@ impl Rules {
             .is_none())
     }
     /// Change rule set status by list ID
-    pub fn set_enabled(&mut self, list_alias: &str, status: bool) -> Option<bool> {
-        self.0
-            .get_mut(list_alias)
-            .map(|list| list.set_enabled(status))
+    pub async fn set_enabled(&mut self, list_alias: &str, status: bool) -> Result<Option<bool>> {
+        Ok(match self.0.get_mut(list_alias) {
+            Some(list) => Some(list.set_enabled(status).await?),
+            None => None,
+        })
     }
     /// Check if rule is exist in the index
     pub fn any(&self, value: &str) -> bool {

src/rules/list.rs

@@ -9,8 +9,8 @@ use std::collections::HashSet;
 
 pub struct List {
     pub is_enabled: bool,
-    //pub source: Source,
     pub rules: HashSet<Rule>,
+    pub source: Source,
 }
 
 impl List {
@@ -18,29 +18,37 @@ impl List {
         let mut rules = HashSet::new();
         let source = Source::from_str(src)?;
         if is_enabled {
-            for line in source.get().await?.lines() {
-                if line.starts_with("/") || line.starts_with("#") || line.is_empty() {
-                    continue; // skip comments
-                }
-                if !rules.insert(Rule::from_line(line)) {
-                    warn!("List `{src}` contains duplicated entry: `{line}`")
-                }
-            }
+            reload(&mut rules, &source).await?;
         }
         Ok(Self {
             rules,
-            //source,
+            source,
             is_enabled,
         })
     }
     /// Change rule set status by list ID
-    pub fn set_enabled(&mut self, is_enabled: bool) -> bool {
+    pub async fn set_enabled(&mut self, is_enabled: bool) -> Result<bool> {
         let was_enabled = self.is_enabled;
         self.is_enabled = is_enabled;
-        was_enabled
+        if is_enabled {
+            reload(&mut self.rules, &self.source).await?;
+        }
+        Ok(was_enabled)
     }
     /// Check if rule is exist in the items index
     pub fn contains(&self, value: &str) -> bool {
         self.is_enabled && self.rules.iter().any(|rule| rule.contains(value))
     }
 }
+async fn reload(rules: &mut HashSet<Rule>, source: &Source) -> Result<()> {
+    rules.clear();
+    for line in source.get().await?.lines() {
+        if line.starts_with("/") || line.starts_with("#") || line.is_empty() {
+            continue; // skip comments
+        }
+        if !rules.insert(Rule::from_line(line)) {
+            warn!("List `{source}` contains duplicated entry: `{line}`")
+        }
+    }
+    Ok(())
+}

src/rules/list/source.rs

@@ -38,3 +38,12 @@ impl FromStr for Source {
         Source::from_str(s)
     }
 }
+
+impl std::fmt::Display for Source {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Path(path) => write!(f, "{}", path.to_string_lossy()),
+            Self::Url(url) => write!(f, "{url}"),
+        }
+    }
+}