fix: improve handling of new type of VEX without advisory description

trustification · Oct 5, 2023 · 4a4ac62 · 4a4ac62
1 parent f1c6991
commit 4a4ac62
Show file tree

Hide file tree

Showing 3 changed files with 30 additions and 21 deletions.
diff --git a/bombastic/index/src/lib.rs b/bombastic/index/src/lib.rs
@@ -525,8 +525,8 @@ impl trustification_index::Index for Index {
         options: &SearchOptions,
     ) -> Result<Self::MatchedDocument, SearchError> {
         let doc = searcher.doc(doc_address)?;
-        let id = field2str(&doc, self.fields.sbom_id)?;
-        let name = field2str(&doc, self.fields.sbom_name)?;
+        let id = field2str(&self.schema, &doc, self.fields.sbom_id)?;
+        let name = field2str(&self.schema, &doc, self.fields.sbom_name)?;
 
         let snippet_generator = SnippetGenerator::create(searcher, &query.query, self.fields.sbom.desc)?;
         let snippet = snippet_generator.snippet_from_doc(&doc).to_html();

diff --git a/index/src/lib.rs b/index/src/lib.rs
@@ -179,8 +179,8 @@ pub enum Error {
     Open(String),
     #[error("error taking snapshot of index")]
     Snapshot,
-    #[error("index not found")]
-    NotFound,
+    #[error("value for field {0} not found")]
+    FieldNotFound(String),
     #[error("operation cannot be done because index is not persisted")]
     NotPersisted,
     #[error("error parsing document {0}")]
@@ -587,11 +587,14 @@ impl<INDEX: Index> IndexStore<INDEX> {
         if options.summaries {
             let mut hits = Vec::new();
             for hit in top_docs {
-                if let Ok(value) = self.index.process_hit(hit.1, hit.0, &searcher, &query, &options) {
-                    debug!("HIT: {:?}", value);
-                    hits.push(value);
-                } else {
-                    warn!("Error processing hit {:?}", hit);
+                match self.index.process_hit(hit.1, hit.0, &searcher, &query, &options) {
+                    Ok(value) => {
+                        debug!("HIT: {:?}", value);
+                        hits.push(value);
+                    }
+                    Err(e) => {
+                        warn!("Error processing hit {:?}: {:?}", hit, e);
+                    }
                 }
             }
 
@@ -752,19 +755,25 @@ pub fn field2f64vec(doc: &Document, field: Field) -> Result<Vec<f64>, Error> {
     Ok(doc.get_all(field).map(|s| s.as_f64().unwrap_or_default()).collect())
 }
 
-pub fn field2str(doc: &Document, field: Field) -> Result<&str, Error> {
+pub fn field2str<'m>(schema: &'m Schema, doc: &'m Document, field: Field) -> Result<&'m str, Error> {
     let value = doc.get_first(field).map(|s| s.as_text()).unwrap_or(None);
-    value.map(Ok).unwrap_or(Err(Error::NotFound))
+    value
+        .map(Ok)
+        .unwrap_or_else(|| Err(Error::FieldNotFound(schema.get_field_name(field).to_string())))
 }
 
-pub fn field2date(doc: &Document, field: Field) -> Result<OffsetDateTime, Error> {
+pub fn field2date(schema: &Schema, doc: &Document, field: Field) -> Result<OffsetDateTime, Error> {
     let value = doc.get_first(field).map(|s| s.as_date()).unwrap_or(None);
-    value.map(|v| Ok(v.into_utc())).unwrap_or(Err(Error::NotFound))
+    value
+        .map(|v| Ok(v.into_utc()))
+        .unwrap_or_else(|| Err(Error::FieldNotFound(schema.get_field_name(field).to_string())))
 }
 
-pub fn field2float(doc: &Document, field: Field) -> Result<f64, Error> {
+pub fn field2float(schema: &Schema, doc: &Document, field: Field) -> Result<f64, Error> {
     let value = doc.get_first(field).map(|s| s.as_f64()).unwrap_or(None);
-    value.map(Ok).unwrap_or(Err(Error::NotFound))
+    value
+        .map(Ok)
+        .unwrap_or_else(|| Err(Error::FieldNotFound(schema.get_field_name(field).to_string())))
 }
 
 #[cfg(test)]

diff --git a/vexination/index/src/lib.rs b/vexination/index/src/lib.rs
@@ -447,18 +447,18 @@ impl trustification_index::Index for Index {
         let snippet_generator = SnippetGenerator::create(searcher, &query.query, self.fields.advisory_description)?;
         let advisory_snippet = snippet_generator.snippet_from_doc(&doc).to_html();
 
-        let advisory_id = field2str(&doc, self.fields.advisory_id)?;
-        let advisory_title = field2str(&doc, self.fields.advisory_title)?;
-        let advisory_severity = field2str(&doc, self.fields.advisory_severity)?;
-        let advisory_date = field2date(&doc, self.fields.advisory_current)?;
-        let advisory_desc = field2str(&doc, self.fields.advisory_description)?;
+        let advisory_id = field2str(&self.schema, &doc, self.fields.advisory_id)?;
+        let advisory_title = field2str(&self.schema, &doc, self.fields.advisory_title)?;
+        let advisory_severity = field2str(&self.schema, &doc, self.fields.advisory_severity)?;
+        let advisory_date = field2date(&self.schema, &doc, self.fields.advisory_current)?;
+        let advisory_desc = field2str(&self.schema, &doc, self.fields.advisory_description).unwrap_or("");
 
         let cves = field2strvec(&doc, self.fields.cve_id)?
             .iter()
             .map(|s| s.to_string())
             .collect();
 
-        let cvss_max: Option<f64> = field2float(&doc, self.fields.cve_cvss_max).ok();
+        let cvss_max: Option<f64> = field2float(&self.schema, &doc, self.fields.cve_cvss_max).ok();
 
         let mut cve_severity_count: HashMap<String, u64> = HashMap::new();
         if let Some(Some(data)) = doc.get_first(self.fields.cve_severity_count).map(|d| d.as_json()) {