Struct ResourceResolver 

pub struct ResourceResolver<'a> { /* private fields */ }

Resolver for looking up resources across the configuration hierarchy.

The resolver implements the “most specific wins” resolution strategy, searching from the most specific scope (service) to the least specific (global) until a match is found.

Example

let resolver = ResourceResolver::new(&config);

// From within a service, "backend" resolves through the chain:
// 1. api:payments:backend (service-local)
// 2. api:backend (namespace)
// 3. backend (exported or global)
let scope = Scope::Service {
    namespace: "api".to_string(),
    service: "payments".to_string(),
};
let upstream = resolver.resolve_upstream("backend", &scope);

Implementations

impl<'a> ResourceResolver<'a>

pub fn new(config: &'a Config) -> Self

Create a new resolver for the given configuration.

pub fn config(&self) -> &'a Config

Get the underlying configuration.

pub fn resolve_upstream( &self, reference: &str, from_scope: &Scope, ) -> Option<&'a UpstreamConfig>

Resolve an upstream reference from the given scope.

Resolution order for unqualified references:

1. Service-local (if in a service scope)
2. Namespace-local (if in a namespace or service scope)
3. Exported from any namespace
4. Global

Qualified references (containing :) resolve directly.

pub fn resolve_agent( &self, reference: &str, from_scope: &Scope, ) -> Option<&'a AgentConfig>

Resolve an agent reference from the given scope.

pub fn resolve_filter( &self, reference: &str, from_scope: &Scope, ) -> Option<&'a FilterConfig>

Resolve a filter reference from the given scope.

pub fn get_namespace(&self, id: &str) -> Option<&'a NamespaceConfig>

Get a namespace by ID.

pub fn get_service( &self, namespace: &str, service: &str, ) -> Option<&'a ServiceConfig>

Get a service by namespace and service ID.

pub fn can_resolve_upstream(&self, reference: &str, from_scope: &Scope) -> bool

Check if an upstream reference can be resolved from the given scope.

pub fn can_resolve_agent(&self, reference: &str, from_scope: &Scope) -> bool

Check if an agent reference can be resolved from the given scope.

pub fn can_resolve_filter(&self, reference: &str, from_scope: &Scope) -> bool

Check if a filter reference can be resolved from the given scope.