Settings reload: no DNS at build time, don't refuse over old failures

A 3-node rehearsal found every settings reload refused, cluster-wide,
because one node couldn't resolve the Pyzor server:

- PyzorConfig::parse resolved the host while building the settings and
  made a failed lookup a build error. It now keeps the host and port and
  resolves when a message is checked (an IP address is used as is, a
  name is reused for five minutes, the lookup counts against the Pyzor
  timeout). A failure there is a Pyzor error for that message.
- A milter's hostname was resolved the same way, with a blocking
  to_socket_addrs in async code. An IP address is kept; a name is now
  resolved on each connection.

Other build-time I/O is already non-fatal: directories that can't
connect become unavailable with a warning (DIR-21), and the AI model
locality check only warns.

reload_registry swapped the core only when the whole build was free of
errors, while boot runs with whatever built. One failing object thus
refused every later reload, and the running settings went stale. Now a
reload is refused only for errors in objects that built when the
running settings were built (at boot or by the last applied reload):
applying it would lose those. Objects that already failed then are
missing from the running settings anyway, as at boot, so their errors
are logged and returned as known_errors but don't hold the reload back.
Refusing on new errors keeps a bad edit from taking a working object
out of service; the admin gets the error instead.

ReloadSettings now says "Settings were not reloaded." and names the
object and its error ("Tracer with id ...: Only one console tracer is
allowed"), with a count of any further errors. A refused reload after a
directory change logs its errors too.

system::reload::reload_tests (new): with Pyzor enabled on an
unresolvable host, ReloadSettings succeeds (on main it fails with
"Invalid address: failed to lookup address information"); an IP host
needs no lookup; a new build error refuses the reload, names the object
and leaves the running settings unchanged; the same error, once known
from the running settings' build, no longer blocks; once fixed, a new
error there blocks again. smtp::inbound::milter's session test now
names its milter "localhost", so the connect-time lookup is exercised.

crates/store/src/backend/mysql/search.rs

@@ -2,8 +2,6 @@
  * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
  *
  * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL
- *
- * Modified by Coffey Labs in 2026 for INBUXA.
  */
 
 use crate::{
@@ -21,7 +19,7 @@ use crate::{
     write::SearchIndex,
 };
 use mysql_async::{IsolationLevel, TxOpts, Value, prelude::Queryable};
-use nlp::{language::Language, tokenizers::word::WordTokenizer};
+use nlp::tokenizers::word::WordTokenizer;
 use std::fmt::Write;
 
 impl MysqlStore {
@@ -148,20 +146,6 @@ impl MysqlStore {
     }
 }
 
-// inbuxa: InnoDB's default full-text stopword list
-// (INFORMATION_SCHEMA.INNODB_FT_DEFAULT_STOPWORD) and innodb_ft_min_token_size
-// default; words outside these are not in a FULLTEXT index.
-const FT_STOPWORDS: &[&str] = &[
-    "a", "about", "an", "are", "as", "at", "be", "by", "com", "de", "en", "for", "from", "how",
-    "i", "in", "is", "it", "la", "of", "on", "or", "that", "the", "this", "to", "was", "what",
-    "when", "where", "who", "will", "with", "und", "www",
-];
-const FT_MIN_TOKEN_SIZE: usize = 3;
-
-fn is_ft_indexed(word: &str) -> bool {
-    word.chars().count() >= FT_MIN_TOKEN_SIZE && !FT_STOPWORDS.contains(&word)
-}
-
 fn build_filter(query: &mut String, filters: &[SearchFilter]) -> Vec<Value> {
     if filters.is_empty() {
         return Vec::new();
@@ -187,77 +171,30 @@ fn build_filter(query: &mut String, filters: &[SearchFilter]) -> Vec<Value> {
 
                 if field.is_text() && matches!(op, SearchOperator::Equal | SearchOperator::Contains)
                 {
-                    let (value, mode, unindexed) = match (value, op) {
-                        (SearchValue::Text { value, .. }, SearchOperator::Equal) => (
-                            Value::Bytes(format!("{value:?}").into_bytes()),
-                            "BOOLEAN",
-                            Vec::new(),
-                        ),
-                        (SearchValue::Text { value, language }, ..) => {
+                    let (value, mode) = match (value, op) {
+                        (SearchValue::Text { value, .. }, SearchOperator::Equal) => {
+                            (Value::Bytes(format!("{value:?}").into_bytes()), "BOOLEAN")
+                        }
+                        (SearchValue::Text { value, .. }, ..) => {
                             let mut text_query = String::with_capacity(value.len() + 1);
-                            let mut unindexed = Vec::new();
 
                             for item in WordTokenizer::new(value, MAX_TOKEN_LENGTH) {
-                                // inbuxa: InnoDB never indexes stopwords ("com",
-                                // "de", "www", ...) or words under
-                                // innodb_ft_min_token_size, and a required
-                                // (+word) term it has not indexed matches no row,
-                                // so "example.com" or "[email protected]" found
-                                // nothing. Such words are matched with a
-                                // word-boundary REGEXP instead.
-                                if is_ft_indexed(&item.word) {
-                                    if !text_query.is_empty() {
-                                        text_query.push(' ');
-                                    }
-                                    text_query.push('+');
-                                    text_query.push_str(&item.word);
-                                } else {
-                                    unindexed.push(item.word);
+                                if !text_query.is_empty() {
+                                    text_query.push(' ');
                                 }
+                                text_query.push('+');
+                                text_query.push_str(&item.word);
                             }
 
-                            // For language text (bodies, subjects) the unindexed
-                            // words are noise words and only checked when nothing
-                            // else is left to match; keyword text (addresses,
-                            // contact fields) checks every word, as the other
-                            // backends do.
-                            if !text_query.is_empty() && !matches!(language, Language::None) {
-                                unindexed.clear();
-                            }
-
-                            (Value::Bytes(text_query.into_bytes()), "BOOLEAN", unindexed)
+                            (Value::Bytes(text_query.into_bytes()), "BOOLEAN")
                         }
                         _ => {
                             debug_assert!(false, "Invalid search value for text field");
                             continue;
                         }
                     };
-                    if unindexed.is_empty() {
-                        let _ =
-                            write!(query, "MATCH({}) AGAINST(? IN {mode} MODE)", field.column());
-                        values.push(value);
-                    } else {
-                        query.push('(');
-                        let is_empty = matches!(&value, Value::Bytes(v) if v.is_empty());
-                        if !is_empty {
-                            let _ = write!(
-                                query,
-                                "MATCH({}) AGAINST(? IN {mode} MODE) AND ",
-                                field.column()
-                            );
-                            values.push(value);
-                        }
-                        for (i, word) in unindexed.iter().enumerate() {
-                            if i > 0 {
-                                query.push_str(" AND ");
-                            }
-                            let _ = write!(query, "{} REGEXP ?", field.column());
-                            values.push(Value::Bytes(
-                                format!("(^|[^[:alnum:]]){word}([^[:alnum:]]|$)").into_bytes(),
-                            ));
-                        }
-                        query.push(')');
-                    }
+                    let _ = write!(query, "MATCH({}) AGAINST(? IN {mode} MODE)", field.column());
+                    values.push(value);
                 } else if let SearchValue::KeyValues(kv) = value {
                     let (key, value) = kv.iter().next().unwrap();
 

crates/store/src/backend/postgres/search.rs

@@ -2,17 +2,12 @@
  * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
  *
  * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL
- *
- * Modified by Coffey Labs in 2026 for INBUXA.
  */
 
 use crate::{
-    backend::{
-        MAX_TOKEN_LENGTH,
-        postgres::{
-            DELETE_CHUNK_SIZE, MIN_DELETE_CHUNK_SIZE, PostgresStore, PsqlSearchField, into_error,
-            into_pool_error, is_timeout_error,
-        },
+    backend::postgres::{
+        DELETE_CHUNK_SIZE, MIN_DELETE_CHUNK_SIZE, PostgresStore, PsqlSearchField, into_error,
+        into_pool_error, is_timeout_error,
     },
     search::{
         IndexDocument, SearchComparator, SearchDocumentId, SearchFilter, SearchOperator,
@@ -20,7 +15,7 @@ use crate::{
     },
     write::SearchIndex,
 };
-use nlp::{language::Language, tokenizers::space::SpaceTokenizer};
+use nlp::language::Language;
 use std::fmt::Write;
 use tokio_postgres::{
     IsolationLevel,
@@ -48,19 +43,6 @@ impl PostgresStore {
             let primary_keys = index.primary_keys();
             let all_fields = index.all_fields();
             let fields = document.fields;
-            // inbuxa: keyword text (addresses, contact fields, ...) is split into
-            // words before it reaches the text parser, see keyword_terms().
-            let keywords = primary_keys
-                .iter()
-                .chain(all_fields)
-                .map(|field| match fields.get(field) {
-                    Some(SearchValue::Text {
-                        value,
-                        language: Language::None,
-                    }) if field.is_text() => Some(keyword_terms(value)),
-                    _ => None,
-                })
-                .collect::<Vec<_>>();
             let mut values = Vec::with_capacity(fields.len() + 2);
             let mut query = format!("INSERT INTO {} (", index.psql_table());
 
@@ -92,20 +74,7 @@ impl PostgresStore {
                         (0, PG_UNSTEMMED_LANG)
                     };
 
-                    if let Some(keywords) = &keywords[i] {
-                        let _ = write!(&mut query, "to_tsvector('{language}',{value_ref})");
-                        values.push(keywords as &(dyn ToSql + Sync));
-                        if field.sort_column().is_some() {
-                            let value_ref = format!("${}", values.len() + 1);
-                            if text_len > 255 {
-                                let _ = write!(&mut query, ",left({value_ref},255)");
-                            } else {
-                                let _ = write!(&mut query, ",{value_ref}");
-                            }
-                            values.push(value as &(dyn ToSql + Sync));
-                        }
-                        continue;
-                    } else if field.is_text() {
+                    if field.is_text() {
                         let _ = write!(&mut query, "to_tsvector('{language}',{value_ref})");
                     } else if text_len > 512 {
                         query.push_str("left(");
@@ -165,7 +134,6 @@ impl PostgresStore {
     ) -> trc::Result<Vec<R>> {
         let mut query = format!("SELECT {} FROM {}", R::field().column(), index.psql_table());
         let params = self.build_filter(&mut query, filters);
-        let params = params.iter().map(SqlParam::as_sql).collect::<Vec<_>>();
         if !sort.is_empty() {
             build_sort(&mut query, sort);
         }
@@ -187,7 +155,6 @@ impl PostgresStore {
         let table = filter.index.psql_table();
         let mut where_clause = String::new();
         let params = self.build_filter(&mut where_clause, &filter.filters);
-        let params = params.iter().map(SqlParam::as_sql).collect::<Vec<_>>();
         let conn = self.conn_pool.get().await.map_err(into_pool_error)?;
         let s = conn
             .prepare_cached(&format!("DELETE FROM {table}{where_clause}"))
@@ -229,7 +196,7 @@ impl PostgresStore {
         &self,
         query: &mut String,
         filters: &'x [SearchFilter],
-    ) -> Vec<SqlParam<'x>> {
+    ) -> Vec<&'x (dyn ToSql + Sync)> {
         if filters.is_empty() {
             return Vec::new();
         }
@@ -270,10 +237,6 @@ impl PostgresStore {
 
                         if matches!(language, Language::None) {
                             let _ = write!(query, "@@ {method}('{config}', ${value_pos})");
-                            if let SearchValue::Text { value, .. } = value {
-                                values.push(SqlParam::Owned(keyword_terms(value)));
-                                continue;
-                            }
                         } else {
                             let _ = write!(query, "@@ ({method}('{config}', ${value_pos})");
                             for fallback in [PG_FALLBACK_LANG, PG_UNSTEMMED_LANG] {
@@ -284,18 +247,18 @@ impl PostgresStore {
                             }
                             query.push(')');
                         }
-                        values.push(SqlParam::Ref(value));
+                        values.push(value as &(dyn ToSql + Sync));
                     } else if let SearchValue::KeyValues(kv) = value {
                         query.push_str(field.column());
                         query.push(' ');
 
                         let (key, value) = kv.iter().next().unwrap();
-                        values.push(SqlParam::Ref(key));
+                        values.push(key as &(dyn ToSql + Sync));
 
                         if !value.is_empty() {
                             let _ = write!(query, "->> ${value_pos} ");
                             op.write_pqsql(query, values.len() + 1);
-                            values.push(SqlParam::Ref(value));
+                            values.push(value as &(dyn ToSql + Sync));
                         } else {
                             let _ = write!(query, " ? ${value_pos}");
                         }
@@ -304,7 +267,7 @@ impl PostgresStore {
                         query.push(' ');
 
                         op.write_pqsql(query, value_pos);
-                        values.push(SqlParam::Ref(value));
+                        values.push(value as &(dyn ToSql + Sync));
                     }
                 }
                 SearchFilter::And | SearchFilter::Or => {
@@ -358,38 +321,6 @@ impl PostgresStore {
     }
 }
 
-// inbuxa: PostgreSQL's text parser keeps "[email protected]" (and host names,
-// URLs, file paths, ...) as a single token, so a search for "user" or
-// "example.com" never matched an address. Keyword text is split into words the
-// same way the built-in index splits it (SpaceTokenizer: lowercase runs of
-// alphanumerics) on both the indexing and the query side, so a full address,
-// its local part, its domain and the display-name words all match, as they do
-// on the other backends.
-pub(crate) fn keyword_terms(value: &str) -> String {
-    let mut terms = String::with_capacity(value.len());
-    for token in SpaceTokenizer::new(value, MAX_TOKEN_LENGTH) {
-        if !terms.is_empty() {
-            terms.push(' ');
-        }
-        terms.push_str(&token);
-    }
-    terms
-}
-
-pub(super) enum SqlParam<'x> {
-    Ref(&'x (dyn ToSql + Sync)),
-    Owned(String),
-}
-
-impl SqlParam<'_> {
-    fn as_sql(&self) -> &(dyn ToSql + Sync) {
-        match self {
-            SqlParam::Ref(value) => *value,
-            SqlParam::Owned(value) => value,
-        }
-    }
-}
-
 fn build_sort(query: &mut String, sort: &[SearchComparator]) {
     query.push_str(" ORDER BY ");
     for (i, comparator) in sort.iter().enumerate() {

tests/src/store/query.rs

@@ -128,11 +128,6 @@ pub async fn test(test: &TestServer) {
     println!("Running trace document tests...");
     test_trace_documents(store.clone()).await;
 
-    // inbuxa: address fields match by full address, local part, domain and
-    // display name on every backend
-    println!("Running address search tests...");
-    test_address_search(store.clone()).await;
-
     // Large document insert test
     println!("Running large document insert tests...");
     let mut large_text = String::with_capacity(20 * 1024 * 1024);
@@ -977,155 +972,3 @@ async fn test_trace_documents(store: SearchStore) {
             .unwrap();
     }
 }
-
-// inbuxa: the message indexer passes each display name and each address of
-// From/To/Cc/Bcc as keyword text (Language::None). The built-in index splits
-// that text into words, so an address is found by its full form, its local
-// part, its domain or a display-name word; PostgreSQL kept the whole address
-// as one token and MySQL dropped stopwords such as "com" and words under three
-// characters. The expected results below are the built-in (RocksDB/SQLite)
-// results and must be the same on every backend.
-async fn test_address_search(store: SearchStore) {
-    const ACCOUNT_ID: u32 = 7;
-    let messages: [[&[(&str, &str)]; 4]; 5] = [
-        // From, To, Cc, Bcc
-        [
-            &[("Amazon.com", "[email protected]")],
-            &[("Jane Doe", "[email protected]")],
-            &[],
-            &[],
-        ],
-        [
-            &[("", "[email protected]")],
-            &[("", "[email protected]")],
-            &[("Jane Doe", "[email protected]")],
-            &[],
-        ],
-        [
-            &[("GitHub", "[email protected]")],
-            &[("Jo Li", "[email protected]")],
-            &[],
-            &[("Audit", "[email protected]")],
-        ],
-        [
-            &[("Jane Doe", "[email protected]")],
-            &[("Amazon Web Services", "[email protected]")],
-            &[("Bob", "[email protected]")],
-            &[("", "[email protected]")],
-        ],
-        [
-            &[("Newsletter", "[email protected]")],
-            &[("", "[email protected]")],
-            &[],
-            &[],
-        ],
-    ];
-    let fields = [
-        EmailSearchField::From,
-        EmailSearchField::To,
-        EmailSearchField::Cc,
-        EmailSearchField::Bcc,
-    ];
-
-    let mut documents = Vec::new();
-    let mut mask = RoaringBitmap::new();
-    for (document_id, message) in messages.iter().enumerate() {
-        let mut document = IndexDocument::new(SearchIndex::Email)
-            .with_account_id(ACCOUNT_ID)
-            .with_document_id(document_id as u32);
-        for (field, addresses) in fields.iter().zip(message.iter()) {
-            for (name, address) in addresses.iter() {
-                if !name.is_empty() {
-                    document.index_text(field.clone(), name, Language::None);
-                }
-                document.index_text(field.clone(), address, Language::None);
-            }
-        }
-        document.index_unsigned(EmailSearchField::ReceivedAt, document_id as u64);
-        documents.push(document);
-        mask.insert(document_id as u32);
-    }
-    store.index(documents).await.unwrap();
-    if let SearchStore::ElasticSearch(store) = &store {
-        store.refresh_index(SearchIndex::Email).await.unwrap();
-    }
-
-    for (field, text, expected) in [
-        // full address
-        (EmailSearchField::From, "[email protected]", vec![0u32]),
-        (EmailSearchField::To, "[email protected]", vec![0]),
-        (EmailSearchField::Cc, "[email protected]", vec![1]),
-        (EmailSearchField::Bcc, "[email protected]", vec![3]),
-        (EmailSearchField::To, "[email protected]", vec![1, 2]),
-        // local part
-        (EmailSearchField::From, "noreply", vec![0, 2]),
-        (EmailSearchField::To, "jo", vec![1, 2]),
-        (EmailSearchField::Cc, "bob", vec![3]),
-        (EmailSearchField::Bcc, "audit", vec![2]),
-        // domain
-        (EmailSearchField::From, "amazon.com", vec![0, 1]),
-        (EmailSearchField::From, "amazon", vec![0, 1]),
-        (EmailSearchField::To, "example.org", vec![0, 4]),
-        (EmailSearchField::To, "io.de", vec![1, 2]),
-        (EmailSearchField::Cc, "example.net", vec![3]),
-        (EmailSearchField::Bcc, "example.org", vec![2]),
-        (EmailSearchField::From, "www.example.com", vec![4]),
-        (EmailSearchField::From, "com", vec![0, 1, 2, 4]),
-        // display name
-        (EmailSearchField::From, "Jane", vec![3]),
-        (EmailSearchField::From, "jane doe", vec![3]),
-        (EmailSearchField::To, "Web Services", vec![3]),
-        (EmailSearchField::To, "Li", vec![2]),
-        (EmailSearchField::Cc, "Doe", vec![1]),
-        (EmailSearchField::Bcc, "Audit", vec![2]),
-        // hyphenated local part
-        (EmailSearchField::From, "shipment-tracking", vec![1]),
-        (EmailSearchField::From, "tracking", vec![1]),
-        // no match
-        (EmailSearchField::From, "amazon.org", vec![]),
-        (EmailSearchField::To, "noreply", vec![]),
-        (EmailSearchField::Bcc, "jane", vec![]),
-    ] {
-        let ids = store
-            .query_account(
-                SearchQuery::new(SearchIndex::Email)
-                    .with_filters(vec![
-                        SearchFilter::eq(SearchField::AccountId, ACCOUNT_ID),
-                        SearchFilter::has_keyword(field.clone(), text),
-                    ])
-                    .with_comparator(SearchComparator::ascending(EmailSearchField::ReceivedAt))
-                    .with_mask(mask.clone()),
-            )
-            .await
-            .unwrap();
-        assert_eq!(ids, expected, "{field:?} {text:?}");
-    }
-
-    // TEXT-style search across all address fields
-    let ids = store
-        .query_account(
-            SearchQuery::new(SearchIndex::Email)
-                .with_filters(vec![
-                    SearchFilter::eq(SearchField::AccountId, ACCOUNT_ID),
-                    SearchFilter::Or,
-                    SearchFilter::has_keyword(EmailSearchField::From, "example.org"),
-                    SearchFilter::has_keyword(EmailSearchField::To, "example.org"),
-                    SearchFilter::has_keyword(EmailSearchField::Cc, "example.org"),
-                    SearchFilter::has_keyword(EmailSearchField::Bcc, "example.org"),
-                    SearchFilter::End,
-                ])
-                .with_comparator(SearchComparator::ascending(EmailSearchField::ReceivedAt))
-                .with_mask(mask.clone()),
-        )
-        .await
-        .unwrap();
-    assert_eq!(ids, vec![0, 1, 2, 3, 4]);
-
-    store
-        .unindex(
-            SearchQuery::new(SearchIndex::Email)
-                .with_filter(SearchFilter::eq(SearchField::AccountId, ACCOUNT_ID)),
-        )
-        .await
-        .unwrap();
-}