"Fossies" - the Fresh Open Source Software Archive

Member "haproxy-2.7.0/doc/lua-api/index.rst" (1 Dec 2022, 125255 Bytes) of package /linux/misc/haproxy-2.7.0.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format (assuming markdown format). Alternatively you can here view or download the uninterpreted source code file. A member file download can also be achieved by clicking within a package contents listing on the according byte size field. See also the latest Fossies "Diffs" side-by-side code changes report for "index.rst": 2.6.6_vs_2.7.0.

How Lua runs in HAProxy

HAProxy Lua running contexts

The Lua code executed in HAProxy can be processed in 2 main modes. The first one is the initialisation mode, and the second is the runtime mode.

The Lua code is loaded in one or more files. These files contains main code and functions. Lua have 7 execution context.

  1. The Lua file body context. It is executed during the load of the Lua file in the HAProxy [global] section with the directive lua-load. It is executed in initialisation mode. This section is use for configuring Lua bindings in HAProxy.

  2. The Lua init context. It is a Lua function executed just after the HAProxy configuration parsing. The execution is in initialisation mode. In this context the HAProxy environment are already initialized. It is useful to check configuration, or initializing socket connections or tasks. These functions are declared in the body context with the Lua function core.register_init(). The prototype of the function is a simple function without return value and without parameters, like this: function fcn().

  3. The Lua task context. It is a Lua function executed after the start of the HAProxy scheduler, and just after the declaration of the task with the Lua function core.register_task(). This context can be concurrent with the traffic processing. It is executed in runtime mode. The prototype of the function is a simple function without return value and without parameters, like this: function fcn().

  4. The action context. It is a Lua function conditionally executed. These actions are registered by the Lua directives "core.register_action()". The prototype of the Lua called function is a function with doesn't returns anything and that take an object of class TXN as entry. function fcn(txn).

  5. The sample-fetch context. This function takes a TXN object as entry argument and returns a string. These types of function cannot execute any blocking function. They are useful to aggregate some of original HAProxy sample-fetches and return the result. The prototype of the function is function string fcn(txn). These functions can be registered with the Lua function core.register_fetches(). Each declared sample-fetch is prefixed by the string "lua.".

    Note

    It is possible that this function cannot found the required data in the original HAProxy sample-fetches, in this case, it cannot return the result. This case is not yet supported

  6. The converter context. It is a Lua function that takes a string as input and returns another string as output. These types of function are stateless, it cannot access to any context. They don't execute any blocking function. The call prototype is function string fcn(string). This function can be registered with the Lua function core.register_converters(). Each declared converter is prefixed by the string "lua.".

  7. The filter context: It is a Lua object based on a class defining filter callback functions. Lua filters are registered using core.register_filter(). Each declared filter is prefixed by the string "lua.".

HAProxy Lua Hello world

HAProxy configuration file (hello_world.conf):

global
   lua-load hello_world.lua

listen proxy
   bind 127.0.0.1:10001
   tcp-request inspect-delay 1s
   tcp-request content use-service lua.hello_world

HAProxy Lua file (hello_world.lua):

core.register_service("hello_world", "tcp", function(applet)
   applet:send("hello world\n")
end)

How to start HAProxy for testing this configuration:

./haproxy -f hello_world.conf

On other terminal, you can test with telnet:

#:~ telnet 127.0.0.1 10001
hello world

Usage of load parameters

HAProxy lua-load(-per-thread) directives allow a list of parameters after the lua file name. These parameters are accessible through an array of args using this code local args = table.pack(...) in the body of loaded file.

Below, a new version of the hello world using load parameters

HAProxy configuration file (hello_world.conf):

global
   lua-load hello_world.lua "this is not an hello world"

listen proxy
   bind 127.0.0.1:10001
   tcp-request inspect-delay 1s
   tcp-request content use-service lua.hello_world

HAProxy Lua file (hello_world.lua):

local args = table.pack(...)

core.register_service("hello_world", "tcp", function(applet)
   applet:send(args[1] .. "\n")
end)

Core class

The "core" class contains all the HAProxy core functions. These function are useful for the controlling of the execution flow, registering hooks, manipulating global maps or ACL, ...

"core" class is basically provided with HAProxy. No require line is required to uses these function.

The "core" class is static, it is not possible to create a new object of this type.

returns

integer

This attribute is an integer, it contains the value of the loglevel "emergency" (0).

returns

integer

This attribute is an integer, it contains the value of the loglevel "alert" (1).

returns

integer

This attribute is an integer, it contains the value of the loglevel "critical" (2).

returns

integer

This attribute is an integer, it contains the value of the loglevel "error" (3).

returns

integer

This attribute is an integer, it contains the value of the loglevel "warning" (4).

returns

integer

This attribute is an integer, it contains the value of the loglevel "notice" (5).

returns

integer

This attribute is an integer, it contains the value of the loglevel "info" (6).

returns

integer

This attribute is an integer, it contains the value of the loglevel "debug" (7).

context: task, action, sample-fetch, converter

This attribute is a table of declared proxies (frontend and backends). Each proxy give an access to his list of listeners and servers. The table is indexed by proxy name, and each entry is of type proxy_class.

Warning

if you declared a frontend and backend with the same name, only one of them will be listed.

see

:jscore.backends

see

:jscore.frontends

context: task, action, sample-fetch, converter

This attribute is a table of declared proxies with backend capability. Each proxy give an access to his list of listeners and servers. The table is indexed by the backend name, and each entry is of type proxy_class.

see

:jscore.proxies

see

:jscore.frontends

context: task, action, sample-fetch, converter

This attribute is a table of declared proxies with frontend capability. Each proxy give an access to his list of listeners and servers. The table is indexed by the frontend name, and each entry is of type proxy_class.

see

:jscore.proxies

see

:jscore.backends

context: task, action, sample-fetch, converter, applet

This variable contains the executing thread number starting at 1. 0 is a special case for the common lua context. So, if thread is 0, Lua scope is shared by all threads, otherwise the scope is dedicated to a single thread. A program which needs to execute some parts exactly once regardless of the number of threads can check that core.thread is 0 or 1.

context: body, init, task, action, sample-fetch, converter

This function sends a log. The log is sent, according with the HAProxy configuration file, on the default syslog server if it is configured and on the stderr if it is allowed.

param integer loglevel

Is the log level associated with the message. It is a number between 0 and 7.

param string msg

The log content.

see

:jscore.emerg, :jscore.alert, :jscore.crit, :jscore.err, :jscore.warning, :jscore.notice, :jscore.info, :jscore.debug (log level definitions)

see

:jscore.Debug

see

:jscore.Info

see

:jscore.Warning

see

:jscore.Alert

context: body, init, task, action, sample-fetch, converter

param string msg

The log content.

see

:jscore.log

Does the same job than:

function Debug(msg)
  core.log(core.debug, msg)
end

context: body, init, task, action, sample-fetch, converter

param string msg

The log content.

see

:jscore.log

function Info(msg)
  core.log(core.info, msg)
end

context: body, init, task, action, sample-fetch, converter

param string msg

The log content.

see

:jscore.log

function Warning(msg)
  core.log(core.warning, msg)
end

context: body, init, task, action, sample-fetch, converter

param string msg

The log content.

see

:jscore.log

function Alert(msg)
  core.log(core.alert, msg)
end

context: init, task, action, sample-fetch, converter

Add the ACL key in the ACLs list referenced by the file filename.

param string filename

the filename that reference the ACL entries.

param string key

the key which will be added.

context: init, task, action, sample-fetch, converter

Delete the ACL entry referenced by the key key in the list of ACLs referenced by filename.

param string filename

the filename that reference the ACL entries.

param string key

the key which will be deleted.

context: init, task, action, sample-fetch, converter

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

param string filename

the filename that reference the map entries.

param string key

the key which will be deleted.

context: body, init, task, action, sample-fetch, converter

Returns HAProxy core information. We can find information like the uptime, the pid, memory pool usage, tasks number, ...

These informations are also returned by the management socket via the command "show info". See the management socket documentation for more information about the content of these variables.

returns

an array of values.

context: body, init, task, action

This function 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. The time is refreshed between each Lua execution or resume, so two consecutive call to the function "now" will probably returns the same result.

returns

a table which contains two entries "sec" and "usec". "sec" contains the current at the epoch format, and "usec" contains the current microseconds.

context: body, init, task, action

This function take 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.

param string date

a date http-date formatted

returns

integer containing epoch date

see

:jscore.imf_date.

see

:jscore.rfc850_date.

see

:jscore.asctime_date.

see

https://tools.ietf.org/html/rfc7231#section-7.1.1.1

context: body, init, task, action

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

param string date

a date IMF formatted

returns

integer containing epoch date

see

https://tools.ietf.org/html/rfc7231#section-7.1.1.1

The IMF format is like this:

Sun, 06 Nov 1994 08:49:37 GMT

context: body, init, task, action

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

param string date

a date RFC859 formatted

returns

integer containing epoch date

see

https://tools.ietf.org/html/rfc7231#section-7.1.1.1

The RFC850 format is like this:

Sunday, 06-Nov-94 08:49:37 GMT

context: body, init, task, action

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

param string date

a date ASCTIME formatted

returns

integer containing epoch date

see

https://tools.ietf.org/html/rfc7231#section-7.1.1.1

The ASCTIME format is like this:

Sun Nov  6 08:49:37 1994

context: body, init, task, action

The core.msleep() stops the Lua execution between specified milliseconds.

param integer milliseconds

the required milliseconds.

context: body

Register a Lua function executed as action. All the registered action can be used in HAProxy with the prefix "lua.". An action gets a TXN object class as input.

param string name

is the name of the converter.

param table actions

is a table of string describing the HAProxy actions who want to register to. The expected actions are 'tcp-req', 'tcp-res', 'http-req' or 'http-res'.

param function func

is the Lua function called to work as converter.

param integer nb_args

is the expected number of argument for the action. By default the value is 0.

The prototype of the Lua function used as argument is:

function(txn [, arg1 [, arg2]])

Here, an example of action registration. The action just send an 'Hello world' in the logs.

core.register_action("hello-world", { "tcp-req", "http-req" }, function(txn)
   txn:Info("Hello world")
end)

This example code is used in HAProxy configuration like this:

frontend tcp_frt
  mode tcp
  tcp-request content lua.hello-world

frontend http_frt
  mode http
  http-request lua.hello-world

A second example using arguments

function hello_world(txn, arg)
   txn:Info("Hello world for " .. arg)
end
core.register_action("hello-world", { "tcp-req", "http-req" }, hello_world, 2)

This example code is used in HAProxy configuration like this:

frontend tcp_frt
  mode tcp
  tcp-request content lua.hello-world everybody

context: body

Register a Lua function executed as converter. All the registered converters can be used in HAProxy with the prefix "lua.". A converter gets a string as input and returns a string as output. The registered function can take up to 9 values as parameter. All the values are strings.

param string name

is the name of the converter.

param function func

is the Lua function called to work as converter.

The prototype of the Lua function used as argument is:

function(str, [p1 [, p2 [, ... [, p5]]]])

context: body

Register a Lua function executed as sample fetch. All the registered sample fetch can be used in HAProxy with the prefix "lua.". A Lua sample fetch returns a string as output. The registered function can take up to 9 values as parameter. All the values are strings.

param string name

is the name of the sample fetch.

param function func

is the Lua function called to work as sample fetch.

The prototype of the Lua function used as argument is:

string function(txn, [p1 [, p2 [, ... [, p5]]]])

lua example code:

core.register_fetches("hello", function(txn)
    return "hello"
end)

HAProxy example configuration:

frontend example
   http-request redirect location /%[lua.hello]

context: body

Register a Lua function used to declare a filter. All the registered filters can by used in HAProxy with the prefix "lua.".

param string name

is the name of the filter.

param table Flt

is a Lua class containing the filter definition (id, flags, callbacks).

param function func

is the Lua function called to create the Lua filter.

The prototype of the Lua function used as argument is:

function(flt, args)

It must return the filter to use or nil to ignore it. Here, an example of filter registration.

core.register_filter("my-filter", MyFilter, function(flt, args)
   flt.args = args -- Save arguments
   return flt
end)

This example code is used in HAProxy configuration like this:

frontend http
  mode http
  filter lua.my-filter arg1 arg2 arg3
see

:jsFilter

context: body

Register a Lua function executed as a service. All the registered services can be used in HAProxy with the prefix "lua.". A service gets an object class as input according with the required mode.

param string name

is the name of the service.

param string mode

is string describing the required mode. Only 'tcp' or 'http' are allowed.

param function func

is the Lua function called to work as service.

The prototype of the Lua function used as argument is:

function(applet)

Warning

Applets of type 'http' cannot be called from 'tcp-' rulesets. Only the 'http-' rulesets are authorized, this means that is not possible to call a HTTP applet from a proxy in tcp mode. Applets of type 'tcp' can be called from anywhere.

Here, an example of service registration. The service just send an 'Hello world' as an http response.

core.register_service("hello-world", "http", function(applet)
   local response = "Hello World !"
   applet:set_status(200)
   applet:add_header("content-length", string.len(response))
   applet:add_header("content-type", "text/plain")
   applet:start_response()
   applet:send(response)
end)

This example code is used in HAProxy configuration like this:

frontend example
   http-request use-service lua.hello-world

context: body

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

param function func

is the Lua function called to work as initializer.

The prototype of the Lua function used as argument is:

function()

It takes no input, and no output is expected.

context: body, init, task, action, sample-fetch, converter

Register and start independent task. The task is started when the HAProxy main scheduler starts. For example this type of tasks can be executed to perform complex health checks.

param function func

is the Lua function called to work as initializer.

The prototype of the Lua function used as argument is:

function()

It takes no input, and no output is expected.

context: body

Register a custom cli that will be available from haproxy stats socket.

param array path

is the sequence of word for which the cli execute the Lua binding.

param string usage

is the usage message displayed in the help.

param function func

is the Lua function called to handle the CLI commands.

The prototype of the Lua function used as argument is:

function(AppletTCP, [arg1, [arg2, [...]]])

I/O are managed with the applettcp_class object. Args are given as parameter. The args embed the registered path. If the path is declared like this:

core.register_cli({"show", "ssl", "stats"}, "Display SSL stats..", function(applet, arg1, arg2, arg3, arg4, arg5)
 end)

And we execute this in the prompt:

> prompt
> show ssl stats all

Then, arg1, arg2 and arg3 will contains respectively "show", "ssl" and "stats". arg4 will contain "all". arg5 contains nil.

context: task, action, sample-fetch, converter

Change the nice of the current task or current session.

param integer nice

the nice value, it must be between -1024 and 1024.

context: init, task, action, sample-fetch, converter

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

param string filename

the Map reference

param string key

the key to set or replace

param string value

the associated value

context: body, init, task, action

The core.sleep() functions stop the Lua execution between specified seconds.

param integer seconds

the required seconds.

context: init, task, action

This function returns a new object of a socket class.

returns

A socket_class object.

context: init, task, action

This function returns a new object of a httpclient class.

returns

A httpclient_class object.

context: body, init, task, action, sample-fetch, converter

This function returns a new concat object.

returns

A concat_class object.

context: body, init, task, action, sample-fetch, converter

param any data

Return some data for the caller. It is useful with sample-fetches and sample-converters.

Immediately stops the current Lua execution and returns to the caller which may be a sample fetch, a converter or an action and returns the specified value (ignored for actions and init). It is used when the LUA process finishes its work and wants to give back the control to HAProxy without executing the remaining code. It can be seen as a multi-level "return".

context: task, action, sample-fetch, converter

Give back the hand at the HAProxy scheduler. It is used when the LUA processing consumes a lot of processing time.

context: body, init, task, action, sample-fetch, converter

param network

is a string describing an ipv4 or ipv6 address and optionally its network length, like this: "127.0.0.1/8" or "aaaa::1234/32".

returns

a userdata containing network or nil if an error occurs.

Parse ipv4 or ipv6 addresses and its facultative associated network.

context: body, init, task, action, sample-fetch, converter

param addr1

is an address created with "core.parse_addr".

param addr2

is an address created with "core.parse_addr".

returns

boolean, true if the network of the addresses match, else returns false.

Match two networks. For example "127.0.0.1/32" matches "127.0.0.0/8". The order of network is not important.

context: body, init, task, action, sample-fetch, converter

This function is useful for tokenizing an entry, or splitting some messages. :param string str: The string which will be split. :param string separators: A string containing a list of separators. :param boolean noblank: Ignore empty entries. :returns: an array of string.

For example:

local array = core.tokenize("This function is useful, for tokenizing an entry.", "., ", true)
print_r(array)

Returns this array:

(table) table: 0x21c01e0 [
    1: (string) "This"
    2: (string) "function"
    3: (string) "is"
    4: (string) "useful"
    5: (string) "for"
    6: (string) "tokenizing"
    7: (string) "an"
    8: (string) "entry"
]

Proxy class

This class provides a way for manipulating proxy and retrieving information like statistics.

Contain the name of the proxy.

Contain the unique identifier of the proxy.

Contain a table with the attached servers. The table is indexed by server name, and each server entry is an object of type server_class.

Contains a stick table object attached to the proxy.

Contain a table with the attached listeners. The table is indexed by listener name, and each each listeners entry is an object of type listener_class.

Pause the proxy. See the management socket documentation for more information.

param class_proxy px

A proxy_class which indicates the manipulated proxy.

Resume the proxy. See the management socket documentation for more information.

param class_proxy px

A proxy_class which indicates the manipulated proxy.

Stop the proxy. See the management socket documentation for more information.

param class_proxy px

A proxy_class which indicates the manipulated proxy.

Kill the session attached to a backup server. See the management socket documentation for more information.

param class_proxy px

A proxy_class which indicates the manipulated proxy.

Returns a string describing the capabilities of the proxy.

param class_proxy px

A proxy_class which indicates the manipulated proxy.

returns

a string "frontend", "backend", "proxy" or "ruleset".

Returns a string describing the mode of the current proxy.

param class_proxy px

A proxy_class which indicates the manipulated proxy.

returns

a string "tcp", "http", "health" or "unknown"

Returns a table containing the proxy statistics. The statistics returned are not the same if the proxy is frontend or a backend.

param class_proxy px

A proxy_class which indicates the manipulated proxy.

returns

a key/value table containing stats

Server class

This class provides a way for manipulating servers and retrieving information.

Contain the name of the server.

Contain the proxy unique identifier of the server.

Return true if the server is currently draining sticky connections.

param class_server sv

A server_class which indicates the manipulated server.

returns

a boolean

Dynamically change the maximum connections of the server. See the management socket documentation for more information about the format of the string.

param class_server sv

A server_class which indicates the manipulated server.

param string maxconn

A string describing the server maximum connections.

This function returns an integer representing the server maximum connections.

param class_server sv

A server_class which indicates the manipulated server.

returns

an integer.

Dynamically change the weight of the server. See the management socket documentation for more information about the format of the string.

param class_server sv

A server_class which indicates the manipulated server.

param string weight

A string describing the server weight.

This function returns an integer representing the server weight.

param class_server sv

A server_class which indicates the manipulated server.

returns

an integer.

Dynamically change the address of the server. See the management socket documentation for more information about the format of the string.

param class_server sv

A server_class which indicates the manipulated server.

param string addr

A string describing the server address.

Returns a string describing the address of the server.

param class_server sv

A server_class which indicates the manipulated server.

returns

A string

Returns server statistics.

param class_server sv

A server_class which indicates the manipulated server.

returns

a key/value table containing stats

Shutdown all the sessions attached to the server. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Drain sticky sessions. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Set maintenance mode. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Set normal mode. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Enable health checks. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Disable health checks. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Force health-check up. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Force health-check nolb mode. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Force health-check down. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Enable agent check. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Disable agent check. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Force agent check up. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Force agent check down. See the management socket documentation for more information about this function.

param class_server sv

A server_class which indicates the manipulated server.

Listener class

Returns server statistics.

param class_listener ls

A listener_class which indicates the manipulated listener.

returns

a key/value table containing stats

Concat class

This class provides a fast way for string concatenation. The way using native Lua concatenation like the code below is slow for some reasons.

str = "string1"
str = str .. ", string2"
str = str .. ", string3"

For each concatenation, Lua: - allocates memory for the result, - catenates the two string copying the strings in the new memory block, - frees the old memory block containing the string which is no longer used.

This process does many memory move, allocation and free. In addition, the memory is not really freed, it is just marked as unused and waits for the garbage collector.

The Concat class provides an alternative way to concatenate strings. It uses the internal Lua mechanism (it does not allocate memory), but it doesn't copy the data more than once.

On my computer, the following loops spends 0.2s for the Concat method and 18.5s for the pure Lua implementation. So, the Concat class is about 1000x faster than the embedded solution.

for j = 1, 100 do
  c = core.concat()
  for i = 1, 20000 do
    c:add("#####")
  end
end
for j = 1, 100 do
  c = ""
  for i = 1, 20000 do
    c = c .. "#####"
  end
end

This function adds a string to the current concatenated string.

param class_concat concat

A concat_class which contains the currently built string.

param string string

A new string to concatenate to the current built string.

This function returns the concatenated string.

param class_concat concat

A concat_class which contains the currently built string.

returns

the concatenated string

Fetches class

This class contains a lot of internal HAProxy sample fetches. See the HAProxy "configuration.txt" documentation for more information. (chapters 7.3.2 to 7.3.6)

Warning

some sample fetches are not available in some context. These limitations are specified in this documentation when they're useful.

see

:jsTXN.f

see

:jsTXN.sf

Fetches are useful to:

function action(txn)
  -- Get source IP
  local clientip = txn.f:src()
end

Converters class

This class contains a lot of internal HAProxy sample converters. See the HAProxy documentation "configuration.txt" for more information about her usage. Its the chapter 7.3.1.

see

:jsTXN.c

see

:jsTXN.sc

Converters provides stateful transformation. They are useful to:

Channel class

context: action, sample-fetch, convert, filter

HAProxy uses two buffers for the processing of the requests. The first one is used with the request data (from the client to the server) and the second is used for the response data (from the server to the client).

Each buffer contains two types of data. The first type is the incoming data waiting for a processing. The second part is the outgoing data already processed. Usually, the incoming data is processed, after it is tagged as outgoing data, and finally it is sent. The following functions provides tools for manipulating these data in a buffer.

The following diagram shows where the channel class function are applied.

image

Warning

It is not possible to read from the response in request action, and it is not possible to read from the request channel in response action.

Warning

It is forbidden to alter the Channels buffer from HTTP contexts. So only :jsChannel.input, :jsChannel.output, :jsChannel.may_recv, :jsChannel.is_full and :jsChannel.is_resp can be called from a HTTP context.

All the functions provided by this class are available in the sample-fetches, actions and filters contexts. For filters, incoming data (offset and length) are relative to the filter. Some functions may yield, but only for actions. Yield is not possible for sample-fetches, converters and filters.

This function copies the string string at the end of incoming data of the channel buffer. The function returns the copied length on success or -1 if data cannot be copied.

Same that :jsChannel.insert(channel, string, channel:input()).

param class_channel channel

The manipulated Channel.

param string string

The data to copy at the end of incoming data.

returns

an integer containing the amount of bytes copied or -1.

This function returns length bytes of incoming data from the channel buffer, starting at the offset offset. The data are not removed from the buffer.

By default, if no length is provided, all incoming data found, starting at the given offset, are returned. If length is set to -1, the function tries to retrieve a maximum of data and, if called by an action, it yields if necessary. It also waits for more data if the requested length exceeds the available amount of incoming data. Not providing an offset is the same as setting it to 0. A positive offset is relative to the beginning of incoming data of the channel buffer while negative offset is relative to the end.

If there is no incoming data and the channel can't receive more data, a 'nil' value is returned.

param class_channel channel

The manipulated Channel.

param integer offset

optional The offset in incoming data to start to get data. 0 by default. May be negative to be relative to the end of incoming data.

param integer length

optional The expected length of data to retrieve. All incoming data by default. May be set to -1 to get a maximum of data.

returns

a string containing the data found or nil.

This function forwards length bytes of data from the channel buffer. If the requested length exceeds the available amount of incoming data, and if called by an action, the function yields, waiting for more data to forward. It returns the amount of data forwarded.

param class_channel channel

The manipulated Channel.

param integer int

The amount of data to forward.

This function returns the length of incoming data in the channel buffer. When called by a filter, this value is relative to the filter.

param class_channel channel

The manipulated Channel.

returns

an integer containing the amount of available bytes.

This function copies the string string at the offset offset in incoming data of the channel buffer. The function returns the copied length on success or -1 if data cannot be copied.

By default, if no offset is provided, the string is copied in front of incoming data. A positive offset is relative to the beginning of incoming data of the channel buffer while negative offset is relative to their end.

param class_channel channel

The manipulated Channel.

param string string

The data to copy into incoming data.

param integer offset

optional The offset in incoming data where to copy data. 0 by default. May be negative to be relative to the end of incoming data.

returns

an integer containing the amount of bytes copied or -1.

This function returns true if the channel buffer is full.

param class_channel channel

The manipulated Channel.

returns

a boolean

This function returns true if the channel is the response one.

param class_channel channel

The manipulated Channel.

returns

a boolean

This function parses length bytes of incoming data of the channel buffer, starting at offset offset, and returns the first line found, including the '\n'. The data are not removed from the buffer. If no line is found, all data are returned.

By default, if no length is provided, all incoming data, starting at the given offset, are evaluated. If length is set to -1, the function tries to retrieve a maximum of data and, if called by an action, yields if necessary. It also waits for more data if the requested length exceeds the available amount of incoming data. Not providing an offset is the same as setting it to 0. A positive offset is relative to the beginning of incoming data of the channel buffer while negative offset is relative to the end.

If there is no incoming data and the channel can't receive more data, a 'nil' value is returned.

param class_channel channel

The manipulated Channel.

param integer offset

optional The offset in incoming data to start to parse data. 0 by default. May be negative to be relative to the end of incoming data.

param integer length

optional The length of data to parse. All incoming data by default. May be set to -1 to get a maximum of data.

returns

a string containing the line found or nil.

This function returns true if the channel may still receive data.

param class_channel channel

The manipulated Channel.

returns

a boolean

This function returns the length of outgoing data of the channel buffer. When called by a filter, this value is relative to the filter.

param class_channel channel

The manipulated Channel.

returns

an integer containing the amount of available bytes.

This function copies the string string in front of incoming data of the channel buffer. The function returns the copied length on success or -1 if data cannot be copied.

Same that :jsChannel.insert(channel, string, 0).

param class_channel channel

The manipulated Channel.

param string string

The data to copy in front of incoming data.

returns

an integer containing the amount of bytes copied or -1.

This function removes length bytes of incoming data of the channel buffer, starting at offset offset. This function returns number of bytes removed on success.

By default, if no length is provided, all incoming data, starting at the given offset, are removed. Not providing an offset is the same as setting it to 0. A positive offset is relative to the beginning of incoming data of the channel buffer while negative offset is relative to the end.

param class_channel channel

The manipulated Channel.

param integer offset

optional The offset in incoming data where to start to remove data. 0 by default. May be negative to be relative to the end of incoming data.

param integer length

optional The length of data to remove. All incoming data by default.

returns

an integer containing the amount of bytes removed.

This function requires immediate send of the string string. It means the string is copied at the beginning of incoming data of the channel buffer and immediately forwarded. Unless if the connection is close, and if called by an action, this function yields to copy and forward all the string.

param class_channel channel

The manipulated Channel.

param string string

The data to send.

returns

an integer containing the amount of bytes copied or -1.

This function replaces length bytes of incoming data of the channel buffer, starting at offset offset, by the string string. The function returns the copied length on success or -1 if data cannot be copied.

By default, if no length is provided, all incoming data, starting at the given offset, are replaced. Not providing an offset is the same as setting it to 0. A positive offset is relative to the beginning of incoming data of the channel buffer while negative offset is relative to the end.

param class_channel channel

The manipulated Channel.

param string string

The data to copy into incoming data.

param integer offset

optional The offset in incoming data where to start the data replacement. 0 by default. May be negative to be relative to the end of incoming data.

param integer length

optional The length of data to replace. All incoming data by default.

returns

an integer containing the amount of bytes copied or -1.

DEPRECATED

This function returns all incoming data found in the channel buffer. The data are not removed from the buffer and can be reprocessed later.

If there is no incoming data and the channel can't receive more data, a 'nil' value is returned.

param class_channel channel

The manipulated Channel.

returns

a string containing all data found or nil.

Warning

This function is deprecated. :jsChannel.data() must be used instead.

DEPRECATED

This function returns all incoming data found in the channel buffer and remove them from the buffer.

If there is no incoming data and the channel can't receive more data, a 'nil' value is returned.

param class_channel channel

The manipulated Channel.

returns

a string containing all the data found or nil.

Warning

This function is deprecated. :jsChannel.data() must be used to retrieve data followed by a call to :jsChannel:remove() to remove data.

local data = chn:data()
chn:remove(0, data:len())

DEPRECATED

This function returns the first line found in incoming data of the channel buffer, including the '\n'. The returned data are removed from the buffer. If no line is found, and if called by an action, this function yields to wait for more data, except if the channel can't receive more data. In this case all data are returned.

If there is no incoming data and the channel can't receive more data, a 'nil' value is returned.

param class_channel channel

The manipulated Channel.

returns

a string containing the line found or nil.

Warning

This function is deprecated. :jsChannel.line() must be used to retrieve a line followed by a call to :jsChannel:remove() to remove data.

local line = chn:line(0, -1)
chn:remove(0, line:len())

DEPRECATED

This function returns the length of the input part of the buffer. When called by a filter, this value is relative to the filter.

param class_channel channel

The manipulated Channel.

returns

an integer containing the amount of available bytes.

Warning

This function is deprecated. :jsChannel.input() must be used instead.

DEPRECATED

This function returns the length of the output part of the buffer. When called by a filter, this value is relative to the filter.

param class_channel channel

The manipulated Channel.

returns

an integer containing the amount of available bytes.

Warning

This function is deprecated. :jsChannel.output() must be used instead.

HTTP class

This class contain all the HTTP manipulation functions.

Returns a table containing all the request headers.

param class_http http

The related http object.

returns

table of headers.

see

:jsHTTP.res_get_headers

This is the form of the returned table:

HTTP:req_get_headers()['<header-name>'][<header-index>] = "<header-value>"

local hdr = HTTP:req_get_headers()
hdr["host"][0] = "www.test.com"
hdr["accept"][0] = "audio/basic q=1"
hdr["accept"][1] = "audio/*, q=0.2"
hdr["accept"][2] = "*/*, q=0.1"

Returns a table containing all the response headers.

param class_http http

The related http object.

returns

table of headers.

see

:jsHTTP.req_get_headers

This is the form of the returned table:

HTTP:res_get_headers()['<header-name>'][<header-index>] = "<header-value>"

local hdr = HTTP:req_get_headers()
hdr["host"][0] = "www.test.com"
hdr["accept"][0] = "audio/basic q=1"
hdr["accept"][1] = "audio/*, q=0.2"
hdr["accept"][2] = "*.*, q=0.1"

Appends a HTTP header field in the request whose name is specified in "name" and whose value is defined in "value".

param class_http http

The related http object.

param string name

The header name.

param string value

The header value.

see

:jsHTTP.res_add_header

Appends a HTTP header field in the response whose name is specified in "name" and whose value is defined in "value".

param class_http http

The related http object.

param string name

The header name.

param string value

The header value.

see

:jsHTTP.req_add_header

Removes all HTTP header fields in the request whose name is specified in "name".

param class_http http

The related http object.

param string name

The header name.

see

:jsHTTP.res_del_header

Removes all HTTP header fields in the response whose name is specified in "name".

param class_http http

The related http object.

param string name

The header name.

see

:jsHTTP.req_del_header

This variable replace all occurrence of all header "name", by only one containing the "value".

param class_http http

The related http object.

param string name

The header name.

param string value

The header value.

see

:jsHTTP.res_set_header

This function does the same work as the following code:

function fcn(txn)
   TXN.http:req_del_header("header")
   TXN.http:req_add_header("header", "value")
end

This function replaces all occurrence of all header "name", by only one containing the "value".

param class_http http

The related http object.

param string name

The header name.

param string value

The header value.

see

:jsHTTP.req_rep_header()

Matches the regular expression in all occurrences of header field "name" according to "regex", and replaces them with the "replace" argument. The replacement value can contain back references like 1, 2, ... This function works with the request.

param class_http http

The related http object.

param string name

The header name.

param string regex

The match regular expression.

param string replace

The replacement value.

see

:jsHTTP.res_rep_header()

Matches the regular expression in all occurrences of header field "name" according to "regex", and replaces them with the "replace" argument. The replacement value can contain back references like 1, 2, ... This function works with the request.

param class_http http

The related http object.

param string name

The header name.

param string regex

The match regular expression.

param string replace

The replacement value.

see

:jsHTTP.req_rep_header()

Rewrites the request method with the parameter "method".

param class_http http

The related http object.

param string method

The new method.

Rewrites the request path with the "path" parameter.

param class_http http

The related http object.

param string path

The new path.

Rewrites the request's query string which appears after the first question mark ("?") with the parameter "query".

param class_http http

The related http object.

param string query

The new query.

Rewrites the request URI with the parameter "uri".

param class_http http

The related http object.

param string uri

The new uri.

Rewrites the response status code with the parameter "code".

If no custom reason is provided, it will be generated from the status.

param class_http http

The related http object.

param integer status

The new response status code.

param string reason

The new response reason (optional).

HTTPClient class

The httpclient class allows issue of outbound HTTP requests through a simple API without the knowledge of HAProxy internals.

Send a HTTP request and wait for a response. GET, HEAD PUT, POST and DELETE methods can be used. The HTTPClient will send asynchronously the data and is able to send and receive more than HAProxy bufsize.

The HTTPClient interface is not able to decompress responses, it is not recommended to send an Accept-Encoding in the request so the response is received uncompressed.

param class httpclient

Is the manipulated HTTPClient.

param table request

Is a table containing the parameters of the request that will be send.

param string request.url

Is a mandatory parameter for the request that contains the URL.

param string request.body

Is an optional parameter for the request that contains the body to send.

param table request.headers

Is an optional parameter for the request that contains the headers to send.

param string request.dst

Is an optional parameter for the destination in haproxy address format.

param integer request.timeout

Optional timeout parameter, set a "timeout server" on the connections.

returns

Lua table containing the response

local httpclient = core.httpclient()
local response = httpclient:post{url="http://127.0.0.1", body=body, dst="unix@/var/run/http.sock"}
response = {
   status  = 400,
   reason  = "Bad request",
   headers = {
       ["content-type"]  = { "text/html" },
       ["cache-control"] = { "no-cache", "no-store" },
   },
   body = "<html><body><h1>invalid request<h1></body></html>",
 }

TXN class

The txn class contain all the functions relative to the http or tcp transaction (Note than a tcp stream is the same than a tcp transaction, but a HTTP transaction is not the same than a tcp stream).

The usage of this class permits to retrieve data from the requests, alter it and forward it.

All the functions provided by this class are available in the context sample-fetches, actions and filters.

returns

An converters_class.

This attribute contains a Converters class object.

returns

An converters_class.

This attribute contains a Converters class object. The functions of this object returns always a string.

returns

An fetches_class.

This attribute contains a Fetches class object.

returns

An fetches_class.

This attribute contains a Fetches class object. The functions of this object returns always a string.

returns

An channel_class.

This attribute contains a channel class object for the request buffer.

returns

An channel_class.

This attribute contains a channel class object for the response buffer.

returns

An http_class.

This attribute contains a HTTP class object. It is available only if the proxy has the "mode http" enabled.

returns

An httpmessage_class.

This attribute contains the request HTTPMessage class object. It is available only if the proxy has the "mode http" enabled and only in the filters context.

returns

An httpmessage_class.

This attribute contains the response HTTPMessage class object. It is available only if the proxy has the "mode http" enabled and only in the filters context.

This function sends a log. The log is sent, according with the HAProxy configuration file, on the default syslog server if it is configured and on the stderr if it is allowed.

param class_txn txn

The class txn object containing the data.

param integer loglevel

Is the log level associated with the message. It is a number between 0 and 7.

param string msg

The log content.

see

:jscore.emerg, :jscore.alert, :jscore.crit, :jscore.err, :jscore.warning, :jscore.notice, :jscore.info, :jscore.debug (log level definitions)

see

:jsTXN.deflog

see

:jsTXN.Debug

see

:jsTXN.Info

see

:jsTXN.Warning

see

:jsTXN.Alert

Sends a log line with the default loglevel for the proxy associated with the transaction.

param class_txn txn

The class txn object containing the data.

param string msg

The log content.

see

:jsTXN.log

param class_txn txn

The class txn object containing the data.

param string msg

The log content.

see

:jsTXN.log

Does the same job as:

function Debug(txn, msg)
  TXN.log(txn, core.debug, msg)
end
param class_txn txn

The class txn object containing the data.

param string msg

The log content.

see

:jsTXN.log

Does the same job as:

function Info(txn, msg)
  TXN.log(txn, core.info, msg)
end
param class_txn txn

The class txn object containing the data.

param string msg

The log content.

see

:jsTXN.log

Does the same job as:

function Warning(txn, msg)
  TXN.log(txn, core.warning, msg)
end
param class_txn txn

The class txn object containing the data.

param string msg

The log content.

see

:jsTXN.log

Does the same job as:

function Alert(txn, msg)
  TXN.log(txn, core.alert, msg)
end

Return Lua data stored in the current transaction (with the TXN.set_priv()) function. If no data are stored, it returns a nil value.

param class_txn txn

The class txn object containing the data.

returns

the opaque data previously stored, or nil if nothing is available.

Store any data in the current HAProxy transaction. This action replaces the old stored data.

param class_txn txn

The class txn object containing the data.

param opaque data

The data which is stored in the transaction.

Converts a Lua type in a HAProxy type and store it in a variable <var>.

param class_txn txn

The class txn object containing the data.

param string var

The variable name according with the HAProxy variable syntax.

param type value

The value associated to the variable. The type can be string or integer.

param boolean ifexist

If this parameter is set to true the variable will only be set if it was defined elsewhere (i.e. used within the configuration). For global variables (using the "proc" scope), they will only be updated and never created. It is highly recommended to always set this to true.

Unset the variable <var>.

param class_txn txn

The class txn object containing the data.

param string var

The variable name according with the HAProxy variable syntax.

Returns data stored in the variable <var> converter in Lua type.

param class_txn txn

The class txn object containing the data.

param string var

The variable name according with the HAProxy variable syntax.

Return a new reply object

param table reply

A table containing info to initialize the reply fields.

returns

A reply_class object.

The table used to initialized the reply object may contain following entries :

local reply = txn:reply{
    status  = 400,
    reason  = "Bad request",
    headers = {
        ["content-type"]  = { "text/html" },
        ["cache-control"] = {"no-cache", "no-store" }
    },
    body = "<html><body><h1>invalid request<h1></body></html>"
}

This function terminates processing of the transaction and the associated session and optionally reply to the client for HTTP sessions.

param class_txn txn

The class txn object containing the data.

param class_reply reply

The class reply object to return to the client.

This functions can be used when a critical error is detected or to terminate processing after some data have been returned to the client (eg: a redirect). To do so, a reply may be provided. This object is optional and may contain a status code, a reason, a header list and a body. All these fields are optional. When not provided, the default values are used. By default, with an empty reply object, an empty HTTP 200 response is returned to the client. If no reply object is provided, the transaction is terminated without any reply. If a reply object is provided, it must not exceed the buffer size once converted into the internal HTTP representation. Because for now there is no easy way to be sure it fits, it is probably better to keep it reasonably small.

The reply object may be fully created in lua or the class Reply may be used to create it.

local reply = txn:reply()
reply:set_status(400, "Bad request")
reply:add_header("content-type", "text/html")
reply:add_header("cache-control", "no-cache")
reply:add_header("cache-control", "no-store")
reply:set_body("<html><body><h1>invalid request<h1></body></html>")
txn:done(reply)
txn:done{
    status  = 400,
    reason  = "Bad request",
    headers = {
        ["content-type"]  = { "text/html" },
        ["cache-control"] = { "no-cache", "no-store" },
    },
    body = "<html><body><h1>invalid request<h1></body></html>"
}

Warning

It does not make sense to call this function from sample-fetches. In this case the behavior is the same than core.done(): it finishes the Lua execution. The transaction is really aborted only from an action registered function.

see

:jsTXN.reply, :jsReply

Is used to change the log level of the current request. The "loglevel" must be an integer between 0 and 7.

param class_txn txn

The class txn object containing the data.

param integer loglevel

The required log level. This variable can be one of

see

:jscore.emerg, :jscore.alert, :jscore.crit, :jscore.err, :jscore.warning, :jscore.notice, :jscore.info, :jscore.debug (log level definitions)

Is used to set the TOS or DSCP field value of packets sent to the client to the value passed in "tos" on platforms which support this.

param class_txn txn

The class txn object containing the data.

param integer tos

The new TOS os DSCP.

Is used to set the Netfilter MARK on all packets sent to the client to the value passed in "mark" on platforms which support it.

param class_txn txn

The class txn object containing the data.

param integer mark

The mark value.

This function adjusts the priority class of the transaction. The value should be within the range -2047..2047. Values outside this range will be truncated.

See the HAProxy configuration.txt file keyword "http-request" action "set-priority-class" for details.

This function adjusts the priority offset of the transaction. The value should be within the range -524287..524287. Values outside this range will be truncated.

See the HAProxy configuration.txt file keyword "http-request" action "set-priority-offset" for details.

Reply class

context: action

This class represents a HTTP response message. It provides some methods to enrich it. Once converted into the internal HTTP representation, the response message must not exceed the buffer size. Because for now there is no easy way to be sure it fits, it is probably better to keep it reasonably small.

See tune.bufsize in the configuration manual for details.

local reply = txn:reply({status = 400}) -- default HTTP 400 reason-phase used
reply:add_header("content-type", "text/html")
reply:add_header("cache-control", "no-cache")
reply:add_header("cache-control", "no-store")
reply:set_body("<html><body><h1>invalid request<h1></body></html>")
see

:jsTXN.reply

The reply status code. By default, the status code is set to 200.

returns

integer

The reason string describing the status code.

returns

string

A table indexing all reply headers by name. To each name is associated an ordered list of values.

returns

Lua table

{
  ["content-type"]  = { "text/html" },
  ["cache-control"] = {"no-cache", "no-store" },
  x_header_name     = { "value1", "value2", ... }
  ...
}

The reply payload.

returns

string

Set the reply status code and optionally the reason-phrase. If the reason is not provided, the default reason corresponding to the status code is used.

param class_reply reply

The related Reply object.

param integer status

The reply status code.

param string reason

The reply status reason (optional).

Add a header to the reply object. If the header does not already exist, a new entry is created with its name as index and a one-element list containing its value as value. Otherwise, the header value is appended to the ordered list of values associated to the header name.

param class_reply reply

The related Reply object.

param string name

The header field name.

param string value

The header field value.

Remove all occurrences of a header name from the reply object.

param class_reply reply

The related Reply object.

param string name

The header field name.

Set the reply payload.

param class_reply reply

The related Reply object.

param string body

The reply payload.

Socket class

This class must be compatible with the Lua Socket class. Only the 'client' functions are available. See the Lua Socket documentation:

http://w3.impa.br/~diego/software/luasocket/tcp.html

Closes a TCP object. The internal socket used by the object is closed and the local address to which the object was bound is made available to other applications. No further operations (except for further calls to the close method) are allowed on a closed Socket.

param class_socket socket

Is the manipulated Socket.

Note: It is important to close all used sockets once they are not needed, since, in many systems, each socket uses a file descriptor, which are limited system resources. Garbage-collected objects are automatically closed before destruction, though.

Attempts to connect a socket object to a remote host.

In case of error, the method returns nil followed by a string describing the error. In case of success, the method returns 1.

param class_socket socket

Is the manipulated Socket.

param string address

can be an IP address or a host name. See below for more information.

param integer port

must be an integer number in the range [1..64K].

returns

1 or nil.

An address field extension permits to use the connect() function to connect to other stream than TCP. The syntax containing a simpleipv4 or ipv6 address is the basically expected format. This format requires the port.

Other format accepted are a socket path like "/socket/path", it permits to connect to a socket. Abstract namespaces are supported with the prefix "abns@", and finally a file descriptor can be passed with the prefix "fd@". The prefix "ipv4@", "ipv6@" and "unix@" are also supported. The port can be passed int the string. The syntax "127.0.0.1:1234" is valid. In this case, the parameter port must not be set.

Same behavior than the function socket:connect, but uses SSL.

param class_socket socket

Is the manipulated Socket.

returns

1 or nil.

Returns information about the remote side of a connected client object.

Returns a string with the IP address of the peer, followed by the port number that peer is using for the connection. In case of error, the method returns nil.

param class_socket socket

Is the manipulated Socket.

returns

a string containing the server information.

Returns the local address information associated to the object.

The method returns a string with local IP address and a number with the port. In case of error, the method returns nil.

param class_socket socket

Is the manipulated Socket.

returns

a string containing the client information.

Reads data from a client object, according to the specified read pattern. Patterns follow the Lua file I/O format, and the difference in performance between all patterns is negligible.

param class_socket socket

Is the manipulated Socket.

param string|integer pattern

Describe what is required (see below).

param string prefix

A string which will be prefix the returned data.

returns

a string containing the required data or nil.

Pattern can be any of the following:

If successful, the method returns the received pattern. In case of error, the method returns nil followed by an error message which can be the string 'closed' in case the connection was closed before the transmission was completed or the string 'timeout' in case there was a timeout during the operation. Also, after the error message, the function returns the partial result of the transmission.

Important note: This function was changed severely. It used to support multiple patterns (but I have never seen this feature used) and now it doesn't anymore. Partial results used to be returned in the same way as successful results. This last feature violated the idea that all functions should return nil on error. Thus it was changed too.

Sends data through client object.

param class_socket socket

Is the manipulated Socket.

param string data

The data that will be sent.

param integer start

The start position in the buffer of the data which will be sent.

param integer end

The end position in the buffer of the data which will be sent.

returns

see below.

Data is the string to be sent. The optional arguments i and j work exactly like the standard string.sub Lua function to allow the selection of a substring to be sent.

If successful, the method returns the index of the last byte within [start, end] that has been sent. Notice that, if start is 1 or absent, this is effectively the total number of bytes sent. In case of error, the method returns nil, followed by an error message, followed by the index of the last byte within [start, end] that has been sent. You might want to try again from the byte following that. The error message can be 'closed' in case the connection was closed before the transmission was completed or the string 'timeout' in case there was a timeout during the operation.

Note: Output is not buffered. For small strings, it is always better to concatenate them in Lua (with the '..' operator) and send the result in one call instead of calling the method several times.

Just implemented for compatibility, this cal does nothing.

Changes the timeout values for the object. All I/O operations are blocking. That is, any call to the methods send, receive, and accept will block indefinitely, until the operation completes. The settimeout method defines a limit on the amount of time the I/O methods can block. When a timeout time has elapsed, the affected methods give up and fail with an error code.

The amount of time to wait is specified as the value parameter, in seconds.

The timeout modes are not implemented, the only settable timeout is the inactivity time waiting for complete the internal buffer send or waiting for receive data.

param class_socket socket

Is the manipulated Socket.

param float value

The timeout value. Use floating point to specify milliseconds.

Regex class

This class allows the usage of HAProxy regexes because classic lua doesn't provides regexes. This class inherits the HAProxy compilation options, so the regexes can be libc regex, pcre regex or pcre JIT regex.

The expression matching number is limited to 20 per regex. The only available option is case sensitive.

Because regexes compilation is a heavy process, it is better to define all your regexes in the body context and use it during the runtime.

-- Create the regex
st, regex = Regex.new("needle (..) (...)", true);

-- Check compilation errors
if st == false then
  print "error: " .. regex
end

-- Match the regexes
print(regex:exec("Looking for a needle in the haystack")) -- true
print(regex:exec("Lokking for a cat in the haystack"))    -- false

-- Extract words
st, list = regex:match("Looking for a needle in the haystack")
print(st)      -- true
print(list[1]) -- needle in the
print(list[2]) -- in
print(list[3]) -- the

Create and compile a regex.

param string regex

The regular expression according with the libc or pcre standard

param boolean case_sensitive

Match is case sensitive or not.

returns

boolean status and regex_class or string containing fail reason.

Execute the regex.

param class_regex regex

A regex_class object.

param string str

The input string will be compared with the compiled regex.

returns

a boolean status according with the match result.

Execute the regex and return matched expressions.

param class_map map

A regex_class object.

param string str

The input string will be compared with the compiled regex.

returns

a boolean status according with the match result, and a table containing all the string matched in order of declaration.

Map class

This class permits to do some lookups in HAProxy maps. The declared maps can be modified during the runtime through the HAProxy management socket.

default = "usa"

-- Create and load map
geo = Map.new("geo.map", Map._ip);

-- Create new fetch that returns the user country
core.register_fetches("country", function(txn)
  local src;
  local loc;

  src = txn.f:fhdr("x-forwarded-for");
  if (src == nil) then
    src = txn.f:src()
    if (src == nil) then
      return default;
    end
  end

  -- Perform lookup
  loc = geo:lookup(src);

  if (loc == nil) then
    return default;
  end

  return loc;
end);

See the HAProxy configuration.txt file, chapter "Using ACLs and fetching samples" and subchapter "ACL basics" to understand this pattern matching method.

Note that :jsMap.int is also available for compatibility.

See the HAProxy configuration.txt file, chapter "Using ACLs and fetching samples" and subchapter "ACL basics" to understand this pattern matching method.

Note that :jsMap.ip is also available for compatibility.

See the HAProxy configuration.txt file, chapter "Using ACLs and fetching samples" and subchapter "ACL basics" to understand this pattern matching method.

Note that :jsMap.str is also available for compatibility.

See the HAProxy configuration.txt file, chapter "Using ACLs and fetching samples" and subchapter "ACL basics" to understand this pattern matching method.

Note that :jsMap.beg is also available for compatibility.

See the HAProxy configuration.txt file, chapter "Using ACLs and fetching samples" and subchapter "ACL basics" to understand this pattern matching method.

Note that :jsMap.sub is also available for compatibility.

See the HAProxy configuration.txt file, chapter "Using ACLs and fetching samples" and subchapter "ACL basics" to understand this pattern matching method.

Note that :jsMap.dir is also available for compatibility.

See the HAProxy configuration.txt file, chapter "Using ACLs and fetching samples" and subchapter "ACL basics" to understand this pattern matching method.

Note that :jsMap.dom is also available for compatibility.

See the HAProxy configuration.txt file, chapter "Using ACLs and fetching samples" and subchapter "ACL basics" to understand this pattern matching method.

See the HAProxy configuration.txt file, chapter "Using ACLs and fetching samples" and subchapter "ACL basics" to understand this pattern matching method.

Note that :jsMap.reg is also available for compatibility.

Creates and load a map.

param string file

Is the file containing the map.

param integer method

Is the map pattern matching method. See the attributes of the Map class.

returns

a class Map object.

see

The Map attributes: :jsMap._int, :jsMap._ip, :jsMap._str, :jsMap._beg, :jsMap._sub, :jsMap._dir, :jsMap._dom, :jsMap._end and :jsMap._reg.

Perform a lookup in a map.

param class_map map

Is the class Map object.

param string str

Is the string used as key.

returns

a string containing the result or nil if no match.

Perform a lookup in a map.

param class_map map

Is the class Map object.

param string str

Is the string used as key.

returns

a string containing the result or empty string if no match.

AppletHTTP class

This class is used with applets that requires the 'http' mode. The http applet can be registered with the core.register_service() function. They are used for processing an http request like a server in back of HAProxy.

This is an hello world sample code:

core.register_service("hello-world", "http", function(applet)
   local response = "Hello World !"
   applet:set_status(200)
   applet:add_header("content-length", string.len(response))
   applet:add_header("content-type", "text/plain")
   applet:start_response()
   applet:send(response)
end)
returns

A converters_class

This attribute contains a Converters class object.

returns

A converters_class

This attribute contains a Converters class object. The functions of this object always return a string.

returns

A fetches_class

This attribute contains a Fetches class object. Note that the applet execution place cannot access to a valid HAProxy core HTTP transaction, so some sample fetches related to the HTTP dependent values (hdr, path, ...) are not available.

returns

A fetches_class

This attribute contains a Fetches class object. The functions of this object always return a string. Note that the applet execution place cannot access to a valid HAProxy core HTTP transaction, so some sample fetches related to the HTTP dependent values (hdr, path, ...) are not available.

returns

string

The attribute method returns a string containing the HTTP method.

returns

string

The attribute version, returns a string containing the HTTP request version.

returns

string

The attribute path returns a string containing the HTTP request path.

returns

string

The attribute qs returns a string containing the HTTP request query string.

returns

integer

The attribute length returns an integer containing the HTTP body length.

returns

table

The attribute headers returns a table containing the HTTP headers. The header names are always in lower case. As the header name can be encountered more than once in each request, the value is indexed with 0 as first index value. The table has this form:

AppletHTTP.headers['<header-name>'][<header-index>] = "<header-value>"

AppletHTTP.headers["host"][0] = "www.test.com"
AppletHTTP.headers["accept"][0] = "audio/basic q=1"
AppletHTTP.headers["accept"][1] = "audio/*, q=0.2"
AppletHTTP.headers["accept"][2] = "*/*, q=0.1"

This function sets the HTTP status code for the response. The allowed code are from 100 to 599.

param class_AppletHTTP applet

An applethttp_class

param integer code

the status code returned to the client.

param string reason

the status reason returned to the client (optional).

This function adds a header in the response. Duplicated headers are not collapsed. The special header content-length is used to determinate the response length. If it does not exist, a transfer-encoding: chunked is set, and all the write from the function AppletHTTP:send() become a chunk.

param class_AppletHTTP applet

An applethttp_class

param string name

the header name

param string value

the header value

This function indicates to the HTTP engine that it can process and send the response headers. After this called we cannot add headers to the response; We cannot use the AppletHTTP:send() function if the AppletHTTP:start_response() is not called.

param class_AppletHTTP applet

An applethttp_class

This function returns a string containing one line from the http body. If the data returned doesn't contains a final '\n' its assumed than its the last available data before the end of stream.

param class_AppletHTTP applet

An applethttp_class

returns

a string. The string can be empty if we reach the end of the stream.

Reads data from the HTTP body, according to the specified read size. If the size is missing, the function tries to read all the content of the stream until the end. If the size is bigger than the http body, it returns the amount of data available.

param class_AppletHTTP applet

An applethttp_class

param integer size

the required read size.

returns

always return a string,the string can be empty is the connection is closed.

Send the message msg on the http request body.

param class_AppletHTTP applet

An applethttp_class

param string msg

the message to send.

Return Lua data stored in the current transaction. If no data are stored, it returns a nil value.

param class_AppletHTTP applet

An applethttp_class

returns

the opaque data previously stored, or nil if nothing is available.

see

:jsAppletHTTP.set_priv

Store any data in the current HAProxy transaction. This action replaces the old stored data.

param class_AppletHTTP applet

An applethttp_class

param opaque data

The data which is stored in the transaction.

see

:jsAppletHTTP.get_priv

Converts a Lua type in a HAProxy type and store it in a variable <var>.

param class_AppletHTTP applet

An applethttp_class

param string var

The variable name according with the HAProxy variable syntax.

param type value

The value associated to the variable. The type ca be string or integer.

param boolean ifexist

If this parameter is set to true the variable will only be set if it was defined elsewhere (i.e. used within the configuration). For global variables (using the "proc" scope), they will only be updated and never created. It is highly recommended to always set this to true.

see

:jsAppletHTTP.unset_var

see

:jsAppletHTTP.get_var

Unset the variable <var>.

param class_AppletHTTP applet

An applethttp_class

param string var

The variable name according with the HAProxy variable syntax.

see

:jsAppletHTTP.set_var

see

:jsAppletHTTP.get_var

Returns data stored in the variable <var> converter in Lua type.

param class_AppletHTTP applet

An applethttp_class

param string var

The variable name according with the HAProxy variable syntax.

see

:jsAppletHTTP.set_var

see

:jsAppletHTTP.unset_var

AppletTCP class

This class is used with applets that requires the 'tcp' mode. The tcp applet can be registered with the core.register_service() function. They are used for processing a tcp stream like a server in back of HAProxy.

returns

A converters_class

This attribute contains a Converters class object.

returns

A converters_class

This attribute contains a Converters class object. The functions of this object always return a string.

returns

A fetches_class

This attribute contains a Fetches class object.

returns

A fetches_class

This attribute contains a Fetches class object.

This function returns a string containing one line from the stream. If the data returned doesn't contains a final '\n' its assumed than its the last available data before the end of stream.

param class_AppletTCP applet

An applettcp_class

returns

a string. The string can be empty if we reach the end of the stream.

Reads data from the TCP stream, according to the specified read size. If the size is missing, the function tries to read all the content of the stream until the end.

param class_AppletTCP applet

An applettcp_class

param integer size

the required read size.

returns

always return a string, the string can be empty if the connection is closed.

Send the message on the stream.

param class_AppletTCP applet

An applettcp_class

param string msg

the message to send.

Return Lua data stored in the current transaction. If no data are stored, it returns a nil value.

param class_AppletTCP applet

An applettcp_class

returns

the opaque data previously stored, or nil if nothing is available.

see

:jsAppletTCP.set_priv

Store any data in the current HAProxy transaction. This action replaces the old stored data.

param class_AppletTCP applet

An applettcp_class

param opaque data

The data which is stored in the transaction.

see

:jsAppletTCP.get_priv

Converts a Lua type in a HAProxy type and stores it in a variable <var>.

param class_AppletTCP applet

An applettcp_class

param string var

The variable name according with the HAProxy variable syntax.

param type value

The value associated to the variable. The type can be string or integer.

param boolean ifexist

If this parameter is set to true the variable will only be set if it was defined elsewhere (i.e. used within the configuration). For global variables (using the "proc" scope), they will only be updated and never created. It is highly recommended to always set this to true.

see

:jsAppletTCP.unset_var

see

:jsAppletTCP.get_var

Unsets the variable <var>.

param class_AppletTCP applet

An applettcp_class

param string var

The variable name according with the HAProxy variable syntax.

see

:jsAppletTCP.unset_var

see

:jsAppletTCP.set_var

Returns data stored in the variable <var> converter in Lua type.

param class_AppletTCP applet

An applettcp_class

param string var

The variable name according with the HAProxy variable syntax.

see

:jsAppletTCP.unset_var

see

:jsAppletTCP.set_var

StickTable class

context: task, action, sample-fetch

This class can be used to access the HAProxy stick tables from Lua.

Returns stick table attributes as a Lua table. See HAProxy documentation for "stick-table" for canonical info, or check out example below.

returns

Lua table

Assume our table has IPv4 key and gpc0 and conn_rate "columns":

{
  expire=<int>,  # Value in ms
  size=<int>,    # Maximum table size
  used=<int>,    # Actual number of entries in table
  data={         # Data columns, with types as key, and periods as values
                   (-1 if type is not rate counter)
    conn_rate=<int>,
    gpc0=-1
  },
  length=<int>,  # max string length for string table keys, key length
                 # otherwise
  nopurge=<boolean>, # purge oldest entries when table is full
  type="ip"      # can be "ip", "ipv6", "integer", "string", "binary"
}

Returns stick table entry for given <key>

param string key

Stick table key (IP addresses and strings are supported)

returns

Lua table

Returns all entries in stick table. An optional filter can be used to extract entries with specific data values. Filter is a table with valid comparison operators as keys followed by data type name and value pairs. Check out the HAProxy docs for "show table" for more details. For the reference, the supported operators are: "eq", "ne", "le", "lt", "ge", "gt"

For large tables, execution of this function can take a long time (for HAProxy standards). That's also true when filter is used, so take care and measure the impact.

param table filter

Stick table filter

returns

Stick table entries (table)

See below for example filter, which contains 4 entries (or comparisons). (Maximum number of filter entries is 4, defined in the source code)

local filter = {
  {"gpc0", "gt", 30}, {"gpc1", "gt", 20}}, {"conn_rate", "le", 10}
}

Action class

context: action

This class contains all return codes an action may return. It is the lua equivalent to HAProxy "ACT_RET*" code.

core.register_action("deny", { "http-req" }, function (txn)
    return act.DENY
 end)

This attribute is an integer (0). It instructs HAProxy to continue the current ruleset processing on the message. It is the default return code for a lua action.

returns

integer

This attribute is an integer (1). It instructs HAProxy to stop the current ruleset processing on the message.

This attribute is an integer (2). It instructs HAProxy to temporarily pause the message processing. It will be resumed later on the same rule. The corresponding lua script is re-executed for the start.

This attribute is an integer (3). It triggers an internal errors The message processing is stopped and the transaction is terminated. For HTTP streams, an HTTP 500 error is returned to the client.

returns

integer

This attribute is an integer (4). It instructs HAProxy to stop the message processing.

returns

integer

This attribute is an integer (5). It denies the current message. The message processing is stopped and the transaction is terminated. For HTTP streams, an HTTP 403 error is returned to the client if the deny is returned during the request analysis. During the response analysis, a HTTP 502 error is returned and the server response is discarded.

returns

integer

This attribute is an integer (6). It aborts the current message. The message processing is stopped and the transaction is terminated. For HTTP streams, HAProxy assumes a response was already sent to the client. From the Lua actions point of view, when this code is used, the transaction is terminated with no reply.

returns

integer

This attribute is an integer (7). It triggers an internal errors. The message processing is stopped and the transaction is terminated. For HTTP streams, an HTTP 400 error is returned to the client if the error is returned during the request analysis. During the response analysis, a HTTP 502 error is returned and the server response is discarded.

returns

integer

context: action

Set the script pause timeout to the specified time, defined in milliseconds.

param integer milliseconds

the required milliseconds.

This function may be used when a lua action returns act.YIELD, to force its wake-up at most after the specified number of milliseconds.

Filter class

context: filter

This class contains return codes some filter callback functions may return. It also contains configuration flags and some helper functions. To understand how the filter API works, see doc/internal/filters.txt documentation.

This attribute is an integer (1). It may be returned by some filter callback functions to instruct this filtering step is finished for this filter.

This attribute is an integer (0). It may be returned by some filter callback functions to instruct the filtering must be paused, waiting for more data or for an external event depending on this filter.

This attribute is an integer (-1). It may be returned by some filter callback functions to trigger an error.

This attribute is a flag corresponding to the filter flag FLT_CFG_FL_HTX. When it is set for a filter, it means the filter is able to filter HTTP streams.

context: filter

Enable the data filtering on the channel chn for the current filter. It may be called at any time from any callback functions proceeding the data analysis.

param class_Channel chn

A channel_class.

context: filter

Disable the data filtering on the channel chn for the current filter. It may be called at any time from any callback functions.

param class_Channel chn

A channel_class.

context: filter

Set the script pause timeout to the specified time, defined in milliseconds.

param integer milliseconds

the required milliseconds.

This function may be used from any lua filter callback function to force its wake-up at most after the specified number of milliseconds. Especially, when filter.CONTINUE is returned.

A filters is declared using :jscore.register_filter() function. The provided class will be used to instantiate filters. It may define following attributes:

Such filter class must also define all required callback functions in the following list. Note that :jsFilter.new() must be defined otherwise the filter is ignored. Others are optional.

Here is a full example:

Trace = {}
Trace.id = "Lua trace filter"
Trace.flags = filter.FLT_CFG_FL_HTX;
Trace.__index = Trace

function Trace:new()
    local trace = {}
    setmetatable(trace, Trace)
    trace.req_len = 0
    trace.res_len = 0
    return trace
end

function Trace:start_analyze(txn, chn)
    if chn:is_resp() then
        print("Start response analysis")
    else
        print("Start request analysis")
    end
    filter.register_data_filter(self, chn)
end

function Trace:end_analyze(txn, chn)
    if chn:is_resp() then
        print("End response analysis: "..self.res_len.." bytes filtered")
    else
        print("End request analysis: "..self.req_len.." bytes filtered")
    end
end

function Trace:http_headers(txn, http_msg)
    stline  = http_msg:get_stline()
    if http_msg.channel:is_resp() then
        print("response:")
        print(stline.version.." "..stline.code.." "..stline.reason)
    else
        print("request:")
        print(stline.method.." "..stline.uri.." "..stline.version)
    end

    for n, hdrs in pairs(http_msg:get_headers()) do
        for i,v in pairs(hdrs) do
            print(n..": "..v)
        end
    end
    return filter.CONTINUE
end

function Trace:http_payload(txn, http_msg)
    body = http_msg:body(-20000)
    if http_msg.channel:is_resp() then
        self.res_len = self.res_len + body:len()
    else
        self.req_len = self.req_len + body:len()
    end
end

core.register_filter("trace", Trace, function(trace, args)
    return trace
end)

HTTPMessage class

context: filter

This class contains all functions to manipulate a HTTP message. For now, this class is only available from a filter context.

Appends a HTTP header field in the HTTP message http_msg whose name is specified in name and whose value is defined in value.

param class_httpmessage http_msg

The manipulated HTTP message.

param string name

The header name.

param string value

The header value.

This function copies the string string at the end of incoming data of the HTTP message http_msg. The function returns the copied length on success or -1 if data cannot be copied.

Same that :jsHTTPMessage.insert(http_msg, string, http_msg:input()).

param class_httpmessage http_msg

The manipulated HTTP message.

param string string

The data to copy at the end of incoming data.

returns

an integer containing the amount of bytes copied or -1.

This function returns length bytes of incoming data from the HTTP message http_msg, starting at the offset offset. The data are not removed from the buffer.

By default, if no length is provided, all incoming data found, starting at the given offset, are returned. If length is set to -1, the function tries to retrieve a maximum of data. Because it is called in the filter context, it never yield. Not providing an offset is the same as setting it to 0. A positive offset is relative to the beginning of incoming data of the http_message buffer while negative offset is relative to their end.

If there is no incoming data and the HTTP message can't receive more data, a 'nil' value is returned.

param class_httpmessage http_msg

The manipulated HTTP message.

param integer offset

optional The offset in incoming data to start to get data. 0 by default. May be negative to be relative to the end of incoming data.

param integer length

optional The expected length of data to retrieve. All incoming data by default. May be set to -1 to get a maximum of data.

returns

a string containing the data found or nil.

This function returns true if the end of message is reached for the HTTP message http_msg.

param class_httpmessage http_msg

The manipulated HTTP message.

returns

an integer containing the amount of available bytes.

Removes all HTTP header fields in the HTTP message http_msg whose name is specified in name.

param class_httpmessage http_msg

The manipulated http message.

param string name

The header name.

Returns a table containing all the headers of the HTTP message http_msg.

param class_httpmessage http_msg

The manipulated http message.

returns

table of headers.

This is the form of the returned table:

http_msg:get_headers()['<header-name>'][<header-index>] = "<header-value>"

local hdr = http_msg:get_headers()
hdr["host"][0] = "www.test.com"
hdr["accept"][0] = "audio/basic q=1"
hdr["accept"][1] = "audio/*, q=0.2"
hdr["accept"][2] = "*.*, q=0.1"

Returns a table containing the start-line of the HTTP message http_msg.

param class_httpmessage http_msg

The manipulated http message.

returns

the start-line.

This is the form of the returned table:

-- for the request :
{"method" = string, "uri" = string, "version" = string}

-- for the response:
{"version" = string, "code" = string, "reason" = string}

This function forwards length bytes of data from the HTTP message http_msg. Because it is called in the filter context, it never yields. Only available incoming data may be forwarded, event if the requested length exceeds the available amount of incoming data. It returns the amount of data forwarded.

param class_httpmessage http_msg

The manipulated HTTP message.

param integer int

The amount of data to forward.

This function returns the length of incoming data in the HTTP message http_msg from the filter point of view.

param class_httpmessage http_msg

The manipulated HTTP message.

returns

an integer containing the amount of available bytes.

This function copies the string string at the offset offset in incoming data of the HTTP message http_msg. The function returns the copied length on success or -1 if data cannot be copied.

By default, if no offset is provided, the string is copied in front of incoming data. A positive offset is relative to the beginning of incoming data of the HTTP message while negative offset is relative to their end.

param class_httpmessage http_msg

The manipulated HTTP message.

param string string

The data to copy into incoming data.

param integer offset

optional The offset in incoming data where to copy data. 0 by default. May be negative to be relative to the end of incoming data.

returns

an integer containing the amount of bytes copied or -1.

This function returns true if the HTTP message http_msg is full.

param class_httpmessage http_msg

The manipulated HTTP message.

returns

a boolean

This function returns true if the HTTP message http_msg is the response one.

param class_httpmessage http_msg

The manipulated HTTP message.

returns

a boolean

This function returns true if the HTTP message http_msg may still receive data.

param class_httpmessage http_msg

The manipulated HTTP message.

returns

a boolean

This function returns the length of outgoing data of the HTTP message http_msg.

param class_httpmessage http_msg

The manipulated HTTP message.

returns

an integer containing the amount of available bytes.

This function copies the string string in front of incoming data of the HTTP message http_msg. The function returns the copied length on success or -1 if data cannot be copied.

Same that :jsHTTPMessage.insert(http_msg, string, 0).

param class_httpmessage http_msg

The manipulated HTTP message.

param string string

The data to copy in front of incoming data.

returns

an integer containing the amount of bytes copied or -1.

This function removes length bytes of incoming data of the HTTP message http_msg, starting at offset offset. This function returns number of bytes removed on success.

By default, if no length is provided, all incoming data, starting at the given offset, are removed. Not providing an offset is the same that setting it to 0. A positive offset is relative to the beginning of incoming data of the HTTP message while negative offset is relative to the end.

param class_httpmessage http_msg

The manipulated HTTP message.

param integer offset

optional The offset in incoming data where to start to remove data. 0 by default. May be negative to be relative to the end of incoming data.

param integer length

optional The length of data to remove. All incoming data by default.

returns

an integer containing the amount of bytes removed.

Matches the regular expression in all occurrences of header field name according to regex regex, and replaces them with the string replace. The replacement value can contain back references like 1, 2, ... This function acts on whole header lines, regardless of the number of values they may contain.

param class_httpmessage http_msg

The manipulated HTTP message.

param string name

The header name.

param string regex

The match regular expression.

param string replace

The replacement value.

Matches the regular expression on every comma-delimited value of header field name according to regex regex, and replaces them with the string replace. The replacement value can contain back references like 1, 2, ...

param class_httpmessage http_msg

The manipulated HTTP message.

param string name

The header name.

param string regex

The match regular expression.

param string replace

The replacement value.

This function requires immediate send of the string string. It means the string is copied at the beginning of incoming data of the HTTP message http_msg and immediately forwarded. Because it is called in the filter context, it never yields.

param class_httpmessage http_msg

The manipulated HTTP message.

param string string

The data to send.

returns

an integer containing the amount of bytes copied or -1.

This function replaces length bytes of incoming data of the HTTP message http_msg, starting at offset offset, by the string string. The function returns the copied length on success or -1 if data cannot be copied.

By default, if no length is provided, all incoming data, starting at the given offset, are replaced. Not providing an offset is the same as setting it to 0. A positive offset is relative to the beginning of incoming data of the HTTP message while negative offset is relative to the end.

param class_httpmessage http_msg

The manipulated HTTP message.

param string string

The data to copy into incoming data.

param integer offset

optional The offset in incoming data where to start the data replacement. 0 by default. May be negative to be relative to the end of incoming data.

param integer length

optional The length of data to replace. All incoming data by default.

returns

an integer containing the amount of bytes copied or -1.

This function set the end of message for the HTTP message http_msg.

param class_httpmessage http_msg

The manipulated HTTP message.

This variable replace all occurrence of all header matching the name name, by only one containing the value value.

param class_httpmessage http_msg

The manipulated HTTP message.

param string name

The header name.

param string value

The header value.

This function does the same work as the following code:

http_msg:del_header("header")
http_msg:add_header("header", "value")

Rewrites the request method with the string method. The HTTP message http_msg must be the request.

param class_httpmessage http_msg

The manipulated HTTP message.

param string method

The new method.

Rewrites the request path with the string path. The HTTP message http_msg must be the request.

param class_httpmessage http_msg

The manipulated HTTP message.

param string method

The new method.

Rewrites the request's query string which appears after the first question mark ("?") with the string query. The HTTP message http_msg must be the request.

param class_httpmessage http_msg

The manipulated HTTP message.

param string query

The new query.

Rewrites the response status code with the integer code and optional the reason reason. If no custom reason is provided, it will be generated from the status. The HTTP message http_msg must be the response.

param class_httpmessage http_msg

The manipulated HTTP message.

param integer status

The new response status code.

param string reason

The new response reason (optional).

Rewrites the request URI with the string uri. The HTTP message http_msg must be the request.

param class_httpmessage http_msg

The manipulated HTTP message.

param string uri

The new uri.

This function remove the end of message for the HTTP message http_msg.

param class_httpmessage http_msg

The manipulated HTTP message.

CertCache class

This class allows to update an SSL certificate file in the memory of the current HAProxy process. It will do the same as "set ssl cert" + "commit ssl cert" over the HAProxy CLI.

This function updates a certificate in memory.

param table certificate

A table containing the fields to update.

param string certificate.filename

The mandatory filename of the certificate to update, it must already exist in memory.

param string certificate.crt

A certificate in the PEM format. It can also contain a private key.

param string certificate.key

A private key in the PEM format.

param string certificate.ocsp

An OCSP response in base64. (cf management.txt)

param string certificate.issuer

The certificate of the OCSP issuer.

param string certificate.sctl

An SCTL file.

CertCache.set{filename="certs/localhost9994.pem.rsa", crt=crt}

External Lua libraries

A lot of useful lua libraries can be found here:

Redis client library:

This is an example about the usage of the Redis library within HAProxy. Note that each call to any function of this library can throw an error if the socket connection fails.

-- load the redis library
local redis = require("redis");

function do_something(txn)

   -- create and connect new tcp socket
   local tcp = core.tcp();
   tcp:settimeout(1);
   tcp:connect("127.0.0.1", 6379);

   -- use the redis library with this new socket
   local client = redis.connect({socket=tcp});
   client:ping();

end

OpenSSL: