Struct LimitConnPlugin 

pub struct LimitConnPlugin {
    role: Role,
    conn: i64,
    burst: i64,
    key: String,
    key_constant: bool,
    rejected_code: u16,
    rejected_msg: Option<String>,
    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_constant: bool

When true, key is used verbatim rather than interpolated.

rejected_code: u16

Status returned when the limit is exceeded.

rejected_msg: Option<String>

Optional human-readable rejection message (JSON {"error_msg": ...}).

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, interpolated per request (see crate::vars::interpolate). 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.
• 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”).

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

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

Executes the plugin logic against the request/response context.