Struct haproxy_api::Core

pub struct Core<'lua> { /* private fields */ }

The “Core” class contains all the HAProxy core functions.

Implementations

impl<'lua> Core<'lua>

pub fn new(lua: &'lua Lua) -> Result<Self>

Creates new Core object using Lua global core

pub fn proxies(&self) -> Result<HashMap<String, Proxy<'lua>>>

Returns a map of declared proxies (frontends and backends), indexed by proxy name.

pub fn backends(&self) -> Result<HashMap<String, Proxy<'lua>>>

Returns a map of declared proxies with backend capability, indexed by the backend name.

pub fn frontends(&self) -> Result<HashMap<String, Proxy<'lua>>>

Returns a map of declared proxies with frontend capability, indexed by the frontend name.

pub fn thread(&self) -> Result<u16>

Returns the executing thread number starting at 0. If thread is 0, Lua scope is shared by all threads, otherwise the scope is dedicated to a single thread. This is HAProxy >=2.4 feature.

pub fn log<S>(&self, level: LogLevel, msg: &S) -> Result<()> where
    S: AsRef<str> + ?Sized, 

Sends a log on the default syslog server if it is configured and on the stderr if it is allowed.

pub fn add_acl(&self, filename: &str, key: &str) -> Result<()>

Adds the ACL key in the ACLs list referenced by filename.

pub fn del_acl(&self, filename: &str, key: &str) -> Result<()>

Deletes the ACL entry by key in the ACLs list referenced by filename.

pub fn del_map(&self, filename: &str, key: &str) -> Result<()>

Deletes the map entry indexed with the specified key in the list of maps referenced by his filename.

pub fn set_map(&self, filename: &str, key: &str, value: &str) -> Result<()>

Sets the value associated to the key in the map referenced by filename.

pub fn get_info(&self) -> Result<Vec<String>>

Returns HAProxy core information (uptime, pid, memory pool usage, tasks number, …).

pub fn now(&self) -> Result<Time>

Returns the current time. The time returned is fixed by the HAProxy core and assures than the hour will be monotonic and that the system call gettimeofday will not be called too.

pub fn http_date(&self, date: &str) -> Result<u64>

Takes a string representing http date, and returns an integer containing the corresponding date with a epoch format. A valid http date me respect the format IMF, RFC850 or ASCTIME.

pub fn imf_date(&self, date: &str) -> Result<u64>

Take a string representing IMF date, and returns an integer containing the corresponding date with a epoch format.

pub fn rfc850_date(&self, date: &str) -> Result<u64>

Takess a string representing RFC850 date, and returns an integer containing the corresponding date with a epoch format.

pub fn asctime_date(&self, date: &str) -> Result<u64>

Takes a string representing ASCTIME date, and returns an integer containing the corresponding date with a epoch format.

pub fn register_action<A, F>(
    &self,
    name: &str,
    actions: &[Action],
    nb_args: usize,
    func: F
) -> Result<()> where
    A: FromLuaMulti<'lua>,
    F: Fn(&'lua Lua, A) -> Result<()> + Send + 'static, 

Registers a function executed as an action. The expected actions are tcp-req, tcp-res, http-req or http-res. All the registered actions can be used in HAProxy with the prefix lua..

pub fn register_async_action<A, F, FR>(
    &self,
    name: &str,
    actions: &[&str],
    nb_args: usize,
    func: F
) -> Result<()> where
    A: FromLuaMulti<'lua>,
    F: Fn(&'lua Lua, A) -> FR + Send + 'static,
    FR: Future<Output = Result<()>> + 'static, 

Registers an asynchronous function executed as an action.

pub fn register_lua_action<S>(
    &self,
    name: &str,
    actions: &[&str],
    nb_args: usize,
    code: &S
) -> Result<()> where
    S: AsChunk<'lua> + ?Sized, 

Same as register_action but using Lua function.

pub fn register_converters<A, R, F>(&self, name: &str, func: F) -> Result<()> where
    A: FromLuaMulti<'lua>,
    R: ToLua<'lua>,
    F: Fn(&'lua Lua, A) -> Result<R> + Send + 'static, 

Registers a function executed as a converter. All the registered converters can be used in HAProxy with the prefix lua..

pub fn register_async_converters<A, R, F, FR>(
    &self,
    name: &str,
    func: F
) -> Result<()> where
    A: FromLuaMulti<'lua>,
    R: ToLua<'lua>,
    F: Fn(&'lua Lua, A) -> FR + Send + 'static,
    FR: Future<Output = Result<R>> + 'static, 

Registers an asynchronous function executed as a converter.

pub fn register_lua_converters<S>(&self, name: &str, code: &S) -> Result<()> where
    S: AsChunk<'lua> + ?Sized, 

Same as register_converters but using Lua function.

pub fn register_fetches<A, R, F>(&self, name: &str, func: F) -> Result<()> where
    A: FromLuaMulti<'lua>,
    R: ToLua<'lua>,
    F: Fn(&'lua Lua, A) -> Result<R> + Send + 'static, 

Registers a function executed as sample fetch. All the registered sample fetch can be used in HAProxy with the prefix lua..

pub fn register_async_fetches<A, R, F, FR>(
    &self,
    name: &str,
    func: F
) -> Result<()> where
    A: FromLuaMulti<'lua>,
    R: ToLua<'lua>,
    F: Fn(&'lua Lua, A) -> FR + Send + 'static,
    FR: Future<Output = Result<R>> + 'static, 

Registers an asynchronous function executed as sample fetch.

pub fn register_lua_fetches<S>(&self, name: &str, code: &S) -> Result<()> where
    S: AsChunk<'lua> + ?Sized, 

Same as register_fetches but using Lua function.

pub fn register_lua_service<S>(
    &self,
    name: &str,
    mode: ServiceMode,
    code: &S
) -> Result<()> where
    S: AsChunk<'lua> + ?Sized, 

Registers a Lua function executed as a service. All the registered service can be used in HAProxy with the prefix lua..

pub fn register_init<F>(&self, func: F) -> Result<()> where
    F: Fn(&'lua Lua) -> Result<()> + Send + 'static, 

Registers a function executed after the configuration parsing. This is useful to check any parameters.

pub fn register_task<F>(&self, func: F) -> Result<()> where
    F: Fn(&'lua Lua) -> Result<()> + Send + 'static, 

Registers and start an independent task. The task is started when the HAProxy main scheduler starts.

pub fn register_async_task<F, FR>(&self, func: F) -> Result<()> where
    F: Fn(&'lua Lua) -> FR + Send + 'static,
    FR: Future<Output = Result<()>> + 'static, 

Registers and start an independent asynchronous task.

pub fn register_lua_task<S>(&self, code: &S) -> Result<()> where
    S: AsChunk<'lua> + ?Sized, 

Same as register_task but using Lua function.

pub fn register_lua_cli<S>(
    &self,
    path: &[&str],
    usage: &str,
    code: &S
) -> Result<()> where
    S: AsChunk<'lua> + ?Sized, 

Registers a Lua function executed as a cli command.

pub fn set_nice(&self, nice: i32) -> Result<()>

Changes the nice of the current task or current session.

pub fn parse_addr(&self, addr: &str) -> Result<AnyUserData<'lua>>

Parses ipv4 or ipv6 addresses and its facultative associated network.

pub fn match_addr(
    &self,
    addr1: AnyUserData<'_>,
    addr2: AnyUserData<'_>
) -> Result<bool>

Matches two networks. For example “127.0.0.1/32” matches “127.0.0.0/8”. The order of network is not important.

Trait Implementations

impl<'lua> Clone for Core<'lua>

fn clone(&self) -> Core<'lua>

Returns a copy of the value.

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

Performs copy-assignment from source.