Struct merino_suggest_providers::KeywordFilterProvider

pub struct KeywordFilterProvider {
    blocklist_ids: Vec<String>,
    blocklist_rules: RegexSet,
    blocklist_hash: Hash,
    inner: Box<dyn SuggestionProvider>,
    metrics_client: StatsdClient,
}

A combinator provider that filters the results from the wrapped provider using a blocklist from the settings.

Fields

blocklist_ids: Vec<String>

The list of ids for the blocklist rules.

blocklist_rules: RegexSet

The regex set containing the blocklist rules. Items have the same sorting order as blocklist_ids.

blocklist_hash: Hash

A hash of all of the rules in this filter, for cache key determination.

inner: Box<dyn SuggestionProvider>

The provider to pull suggestions from.

metrics_client: StatsdClient

The Statsd client used to record statistics.

Implementations

impl KeywordFilterProvider

pub fn new_boxed(
    config: KeywordFilterConfig,
    inner: Box<dyn SuggestionProvider>,
    metrics_client: StatsdClient
) -> Result<Box<Self>, SetupError>

Construct a new, boxed filter provider.

fn prep_blocklist(
    blocklist: HashMap<String, String>
) -> Result<(Vec<String>, Hash, RegexSet), SetupError>

Convert a map from rule IDs to blocking regexes, and build the data structures needed to efficiently apply those rules. Used to initialize or reconfigure this provider.

Trait Implementations

impl SuggestionProvider for KeywordFilterProvider

fn name(&self) -> String

An operator-visible name for this suggestion provider.

fn cache_inputs(
    &self,
    req: &SuggestionRequest,
    cache_inputs: &mut dyn CacheInputs
)

Generate a set of cache inputs for a given query specific to this provider. Any property of the query that affects how suggestions are generated should be included.

fn suggest<'life0, 'async_trait>(
    &'life0 self,
    query: SuggestionRequest
) -> Pin<Box<dyn Future<Output = Result<SuggestionResponse, SuggestError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Provide suggested results for query.

fn reconfigure<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    new_config: Value,
    make_fresh: &'life1 MakeFreshType
) -> Pin<Box<dyn Future<Output = Result<(), SetupError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Reconfigure the provider, using a new configuration object. State should be preserved if possible.

fn is_null(&self) -> bool

Return if this provider is null and can be ignored. Providers that set this to true should be ignored in any place where suggestions are needed. Providers with this set to true likely only serve as a blank space where we may need a provider but can’t otherwise supply one.

fn cache_key(&self, req: &SuggestionRequest) -> String

Use Self::cache_inputs to generate a single cache key. This function should not normally be overridden by provider implementations.