Struct NamespaceConfig 

pub struct NamespaceConfig {
    pub id: String,
    pub limits: Option<Limits>,
    pub listeners: Vec<ListenerConfig>,
    pub upstreams: HashMap<String, UpstreamConfig>,
    pub routes: Vec<RouteConfig>,
    pub agents: Vec<AgentConfig>,
    pub filters: HashMap<String, FilterConfig>,
    pub services: Vec<ServiceConfig>,
    pub exports: ExportConfig,
}

Configuration for a namespace - a logical grouping of related resources.

Namespaces provide domain-driven boundaries within the configuration, allowing operators to organize resources by team, service domain, or any other logical grouping.

Example KDL

namespace "api" {
    limits {
        max-body-size 10485760
    }

    upstreams {
        upstream "backend" { ... }
    }

    routes {
        route "users" {
            upstream "backend"  // Resolves to api:backend
        }
    }

    service "payments" {
        // Service-specific configuration
    }

    exports {
        upstreams "backend"  // Make globally visible
    }
}

Fields

id: String

Unique namespace identifier.

Must not contain the : character as it’s reserved for qualified ID syntax (e.g., namespace:resource).

limits: Option<Limits>

Namespace-level limits.

These limits override global limits and are overridden by service-level limits. If not specified, global limits apply.

listeners: Vec<ListenerConfig>

Namespace-level listeners.

Listeners at the namespace level are shared across all services within the namespace.

upstreams: HashMap<String, UpstreamConfig>

Namespace-level upstreams.

These upstreams are visible to all routes within the namespace and its services. They can be referenced without qualification from within the namespace.

routes: Vec<RouteConfig>

Namespace-level routes.

Routes defined at the namespace level can reference namespace upstreams without qualification.

agents: Vec<AgentConfig>

Namespace-level agents.

Agents at this level are visible to all filters within the namespace and its services.

filters: HashMap<String, FilterConfig>

Namespace-level filters.

Filters at this level can be referenced by routes within the namespace and its services.

services: Vec<ServiceConfig>

Services within this namespace.

Services provide more granular grouping within a namespace, typically representing individual microservices or API groups.

exports: ExportConfig

Resources exported from this namespace.

Exported resources become globally visible and can be referenced from any scope without qualification.

Implementations

impl NamespaceConfig

pub fn new(id: impl Into<String>) -> Self

Create a new namespace with the given ID.

pub fn is_empty(&self) -> bool

Returns true if this namespace contains no resources.

pub fn get_service(&self, id: &str) -> Option<&ServiceConfig>

Get a service by ID within this namespace.

pub fn get_service_mut(&mut self, id: &str) -> Option<&mut ServiceConfig>

Get a mutable service by ID within this namespace.

Trait Implementations

impl Clone for NamespaceConfig

fn clone(&self) -> NamespaceConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NamespaceConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for NamespaceConfig

fn default() -> NamespaceConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NamespaceConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for NamespaceConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.