Fix: Feed is loaded many times in readis after openvasd restart

rust/feed/src/update/mod.rs

@@ -107,6 +107,18 @@ where
         feed_version(self.loader, self.dispatcher)
     }
 
+    /// Check if the current feed is outdated.
+    pub fn feed_is_outdated(&self, current_version: String) -> Result<bool, ErrorKind> {
+        self.verify_signature()?;
+        // the version in file
+        let v = self.feed_version()?;
+        if !current_version.is_empty() {
+            return Ok(v.as_str() != current_version.as_str());
+        };
+
+        Ok(true)
+    }
+
     /// plugin_feed_info must be handled differently.
     ///
     /// Usually a plugin_feed_info.inc is setup as a listing of keys.

rust/openvasd/src/storage/mod.rs

@@ -186,6 +186,11 @@ pub trait NVTStorer {
 
     /// Returns the currently stored feed hash.
     async fn feed_hash(&self) -> Vec<FeedHash>;
+
+    /// Returns the current feed version, if any.
+    async fn current_feed_version(&self) -> Result<String, Error> {
+        Ok("".to_string())
+    }
 }
 
 #[async_trait]

rust/openvasd/src/storage/redis.rs

@@ -69,7 +69,7 @@ impl<T> Storage<T> {
         .unwrap()
     }
 
-    async fn update_nasl(url: Arc<String>, p: PathBuf) -> Result<(), Error> {
+    async fn update_nasl(url: Arc<String>, p: PathBuf, current_feed: String) -> Result<(), Error> {
         let nasl_feed_path = p;
         tokio::task::spawn_blocking(move || {
             tracing::debug!("starting nasl feed update");
@@ -79,8 +79,13 @@ impl<T> Storage<T> {
 
             let redis_cache: CacheDispatcher<RedisCtx> =
                 redis_storage::CacheDispatcher::init(&url, FEEDUPDATE_SELECTOR)?;
+
             let store = PerItemDispatcher::new(redis_cache);
             let mut fu = feed::Update::init(oversion, 5, &loader, &store, verifier);
+            if !fu.feed_is_outdated(current_feed).unwrap() {
+                return Ok(());
+            }
+
             if let Some(x) = fu.find_map(|x| x.err()) {
                 Err(Error::from(x))
             } else {
@@ -181,7 +186,12 @@ where
         for h in &hash {
             match h.typus {
                 FeedType::NASL => {
-                    _ = updates.spawn(Self::update_nasl(self.url.clone(), h.path.clone()))
+                    let current_feed = self.current_feed_version().await?;
+                    _ = updates.spawn(Self::update_nasl(
+                        self.url.clone(),
+                        h.path.clone(),
+                        current_feed,
+                    ))
                 }
                 FeedType::Advisories => {
                     _ = updates.spawn(Self::update_advisories(self.url.clone(), h.path.clone()))
@@ -284,6 +294,21 @@ where
     async fn feed_hash(&self) -> Vec<FeedHash> {
         self.hash.read().await.to_vec()
     }
+
+    async fn current_feed_version(&self) -> Result<String, Error> {
+        let url = self.url.to_string();
+        let cache_version = tokio::task::spawn_blocking(move || {
+            let mut cache = RedisCtx::open(&url, FEEDUPDATE_SELECTOR)?;
+            let version = cache.lindex("nvticache", 0)?;
+            if version.clone().is_empty() {
+                let _ = cache.delete_namespace();
+            }
+            Ok::<_, Error>(version)
+        })
+        .await
+        .unwrap()?;
+        Ok(cache_version)
+    }
 }
 
 #[async_trait]

rust/redis-storage/src/connector.rs

@@ -194,6 +194,7 @@ pub const NOTUSUPDATE_SELECTOR: &[NameSpaceSelector] =
 pub trait RedisWrapper {
     fn rpush<T: ToRedisArgs>(&mut self, key: &str, val: T) -> RedisStorageResult<()>;
     fn lpush<T: ToRedisArgs>(&mut self, key: &str, val: T) -> RedisStorageResult<()>;
+    fn del(&mut self, key: &str) -> RedisStorageResult<()>;
     fn lindex(&mut self, key: &str, index: isize) -> RedisStorageResult<String>;
     fn lrange(&mut self, key: &str, start: isize, end: isize) -> RedisStorageResult<Vec<String>>;
     fn keys(&mut self, pattern: &str) -> RedisStorageResult<Vec<String>>;
@@ -221,6 +222,16 @@ impl RedisWrapper for RedisCtx {
             .map_err(|e| e.into())
     }
 
+    ///Wrapper function to avoid accessing kb member directly.
+    #[inline(always)]
+    fn del(&mut self, key: &str) -> RedisStorageResult<()> {
+        self.kb
+            .as_mut()
+            .expect("Valid redis connection")
+            .del(key)
+            .map_err(|e| e.into())
+    }
+
     ///Wrapper function to avoid accessing kb member directly.
     #[inline(always)]
     fn lindex(&mut self, key: &str, index: isize) -> RedisStorageResult<String> {
@@ -551,12 +562,14 @@ pub trait RedisAddNvt: RedisWrapper {
             &family,
             &name,
         ];
+        self.del(&key_name)?;
         self.rpush(&key_name, &values)?;
 
         // Add preferences
         let prefs = Self::prefs(&nvt.preferences);
         if !prefs.is_empty() {
             let key_name = format!("oid:{oid}:prefs");
+            self.del(&key_name)?;
             self.lpush(&key_name, prefs)?;
             //self.kb.lpush(&key_name, prefs)?;
         }
@@ -721,6 +734,7 @@ where
 
     fn dispatch_feed_version(&self, version: String) -> Result<(), StorageError> {
         let mut cache = Arc::as_ref(&self.cache).lock()?;
+        cache.del(CACHE_KEY)?;
         cache.rpush(CACHE_KEY, &[&version]).map_err(|e| e.into())
     }
 
@@ -812,6 +826,10 @@ mod tests {
                 .unwrap();
             Ok(())
         }
+        fn del(&mut self, _: &str) -> crate::dberror::RedisStorageResult<()> {
+            Ok(())
+        }
+
         fn lindex(&mut self, _: &str, _: isize) -> crate::dberror::RedisStorageResult<String> {
             Ok(String::new())
         }