Struct LimitConnPlugin 

pub struct LimitConnPlugin {
    role: Role,
    conn: i64,
    burst: i64,
    key: String,
    key_tpl: Template,
    key_constant: bool,
    rejected_code: u16,
    rejected_msg: Option<Template>,
    resources: Arc<PluginResources>,
}

One node of a limit-conn acquire/release pair.

Holds a handle to the process-wide crate::traffic::ConnRegistry; the per-key counter is resolved at request time from the interpolated key so concurrency is measured per client (or per whatever the key selects), shared across both nodes of the pair.

Fields

role: Role

conn: i64

Maximum sustained concurrent requests.

burst: i64

Extra concurrent requests tolerated above conn.

key: String

Key template (interpolated per request unless key_type is constant).

key_tpl: Template

Pre-parsed key: supports {{namespace.path}} references and legacy $var interpolation (see Template::render_with_legacy). Only used when key_constant is false.

key_constant: bool

When true, key is used verbatim rather than interpolated.

rejected_code: u16

Status returned when the limit is exceeded.

rejected_msg: Option<Template>

Optional human-readable rejection message (JSON {"error_msg": ...}). Supports {{namespace.path}} references (no legacy $var interpolation — this field never supported it, so this sweep must not start).

resources: Arc<PluginResources>

Implementations

impl LimitConnPlugin

pub fn from_config( config: &HashMap<String, Value>, resources: &Arc<PluginResources>, ) -> Result<Self, String>

Builds one node of the pair from node config.

Accepted keys:

• phase / role (string, required): acquire (before upstream) or release (after upstream). Any other value is a config error.
• conn (integer, default 20): maximum sustained concurrent requests. Must be > 0.
• burst (integer, default 0): extra concurrent requests tolerated above conn. Must be >= 0. The hard ceiling is conn + burst.
• key (string template, default "$remote_addr"): the concurrency key, rendered per request — supports {{namespace.path}} references plus legacy $var interpolation (see crate::vars::template::Template::render_with_legacy) unless key_type: constant. Both nodes of a pair must use the same key and conn/burst so they share one counter.
• key_type (string, default var): constant uses key verbatim; any other value (var, var_combination) interpolates it.
• rejected_code (integer, default 503): status for over-limit requests.
• rejected_msg (string, optional): message returned as a JSON body {"error_msg": "..."} on rejection. Supports {{namespace.path}} references.
• default_conn_delay (number, optional): accepted for APISIX config compatibility but ignored — featherbit rejects rather than delays.

# before upstream
type: limit-conn
config:
  phase: acquire
  conn: 100
  burst: 50
  key: $remote_addr
  rejected_code: 503
---
# after upstream (on both success and error paths)
type: limit-conn
config:
  phase: release
  conn: 100
  burst: 50
  key: $remote_addr

fn resolve_key(&self, ctx: &Context) -> String

Resolves the concurrency key for this request.

Trait Implementations

impl Plugin for LimitConnPlugin

fn plugin_type(&self) -> &str

Unique identifier for the plugin type (e.g., “proxy-rewrite”, “upstream”). This is also the key its PortSpec is registered under in port_spec.

fn execute<'life0, 'async_trait>( &'life0 self, ctx: Context, ) -> Pin<Box<dyn Future<Output = Result<PluginOutput, PluginExecutionError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Executes the plugin logic against the request/response context.

fn reads_response_body(&self) -> bool

Whether this configured instance reads context.response.body.

fn cache_target(&self) -> Option<CacheTarget>

The cache backend this node writes to, if it is a proxy-cache half.