1250 lines
45 KiB
Plaintext
1250 lines
45 KiB
Plaintext
-----------------------------------------------
|
|
Stream Processing Offload Engine (SPOE)
|
|
Version 1.2
|
|
( Last update: 2020-06-13 )
|
|
-----------------------------------------------
|
|
Author : Christopher Faulet
|
|
Contact : cfaulet at haproxy dot com
|
|
|
|
|
|
SUMMARY
|
|
--------
|
|
|
|
0. Terms
|
|
1. Introduction
|
|
2. SPOE configuration
|
|
2.1. SPOE scope
|
|
2.2. "spoe-agent" section
|
|
2.3. "spoe-message" section
|
|
2.4. "spoe-group" section
|
|
2.5. Example
|
|
3. SPOP specification
|
|
3.1. Data types
|
|
3.2. Frames
|
|
3.2.1. Frame capabilities
|
|
3.2.2. Frame types overview
|
|
3.2.3. Workflow
|
|
3.2.4. Frame: HAPROXY-HELLO
|
|
3.2.5. Frame: AGENT-HELLO
|
|
3.2.6. Frame: NOTIFY
|
|
3.2.7. Frame: ACK
|
|
3.2.8. Frame: HAPROXY-DISCONNECT
|
|
3.2.9. Frame: AGENT-DISCONNECT
|
|
3.3. Events & messages
|
|
3.4. Actions
|
|
3.5. Errors & timeouts
|
|
4. Logging
|
|
|
|
|
|
0. Terms
|
|
---------
|
|
|
|
* SPOE : Stream Processing Offload Engine.
|
|
|
|
A SPOE is a filter talking to servers managed by a SPOA to offload the
|
|
stream processing. An engine is attached to a proxy. A proxy can have
|
|
several engines. Each engine is linked to an agent and only one.
|
|
|
|
* SPOA : Stream Processing Offload Agent.
|
|
|
|
A SPOA is a service that will receive info from a SPOE to offload the
|
|
stream processing. An agent manages several servers. It uses a backend to
|
|
reference all of them. By extension, these servers can also be called
|
|
agents.
|
|
|
|
* SPOP : Stream Processing Offload Protocol, used by SPOEs to talk to SPOA
|
|
servers.
|
|
|
|
This protocol is used by engines to talk to agents. It is an in-house
|
|
binary protocol described in this documentation.
|
|
|
|
|
|
1. Introduction
|
|
----------------
|
|
|
|
SPOE is a feature introduced in HAProxy 1.7. It makes possible the
|
|
communication with external components to retrieve some info. The idea started
|
|
with the problems caused by most ldap libs not working fine in event-driven
|
|
systems (often at least the connect() is blocking). So, it is hard to properly
|
|
implement Single Sign On solution (SSO) in HAProxy. The SPOE will ease this
|
|
kind of processing, or we hope so.
|
|
|
|
Now, the aim of SPOE is to allow any kind of offloading on the streams. First
|
|
releases won't do lot of things. As we will see, there are few handled events
|
|
and even less actions supported. Actually, for now, the SPOE can offload the
|
|
processing before "tcp-request content", "tcp-response content", "http-request"
|
|
and "http-response" rules. And it only supports variables definition. But, in
|
|
spite of these limited features, we can easily imagine to implement SSO
|
|
solution, ip reputation or ip geolocation services.
|
|
|
|
|
|
2. SPOE configuration
|
|
----------------------
|
|
|
|
Because SPOE is implemented as a filter, To use it, you must declare a "filter
|
|
spoe" line in a proxy section (frontend/backend/listen) :
|
|
|
|
frontend my-front
|
|
...
|
|
filter spoe [engine <name>] config <file>
|
|
...
|
|
|
|
The "config" parameter is mandatory. It specififies the SPOE configuration
|
|
file. The engine name is optional. It can be set to declare the scope to use in
|
|
the SPOE configuration. So it is possible to use the same SPOE configuration
|
|
for several engines. If no name is provided, the SPOE configuration must not
|
|
contain any scope directive.
|
|
|
|
We use a separate configuration file on purpose. By commenting SPOE filter
|
|
line, you completely disable the feature, including the parsing of sections
|
|
reserved to SPOE. This is also a way to keep the HAProxy configuration clean.
|
|
|
|
A SPOE configuration file must contains, at least, the SPOA configuration
|
|
("spoe-agent" section) and SPOE messages/groups ("spoe-message" or "spoe-group"
|
|
sections) attached to this agent.
|
|
|
|
IMPORTANT : The configuration of a SPOE filter must be located in a dedicated
|
|
file. But the backend used by a SPOA must be declared in HAProxy configuration
|
|
file.
|
|
|
|
2.1. SPOE scope
|
|
-------------------------
|
|
|
|
If you specify an engine name on the SPOE filter line, then you need to define
|
|
scope in the SPOE configuration with the same name. You can have several SPOE
|
|
scope in the same file. In each scope, you must define one and only one
|
|
"spoe-agent" section to configure the SPOA linked to your SPOE and several
|
|
"spoe-message" and "spoe-group" sections to describe, respectively, messages and
|
|
group of messages sent to servers mananged by your SPOA.
|
|
|
|
A SPOE scope starts with this kind of line :
|
|
|
|
[<name>]
|
|
|
|
where <name> is the same engine name specified on the SPOE filter line. The
|
|
scope ends when the file ends or when another scope is found.
|
|
|
|
Example :
|
|
[my-first-engine]
|
|
spoe-agent my-agent
|
|
...
|
|
spoe-message msg1
|
|
...
|
|
spoe-message msg2
|
|
...
|
|
spoe-group grp1
|
|
...
|
|
spoe-group grp2
|
|
...
|
|
|
|
[my-second-engine]
|
|
...
|
|
|
|
If no engine name is provided on the SPOE filter line, no SPOE scope must be
|
|
found in the SPOE configuration file. All the file is considered to be in the
|
|
same anonymous and implicit scope.
|
|
|
|
The engine name must be uniq for a proxy. If no engine name is provided on the
|
|
SPOE filter line, the SPOE agent name is used by default.
|
|
|
|
2.2. "spoe-agent" section
|
|
--------------------------
|
|
|
|
For each engine, you must define one and only one "spoe-agent" section. In this
|
|
section, you will declare SPOE messages and the backend you will use. You will
|
|
also set timeouts and options to customize your agent's behaviour.
|
|
|
|
|
|
spoe-agent <name>
|
|
Create a new SPOA with the name <name>. It must have one and only one
|
|
"spoe-agent" definition by SPOE scope.
|
|
|
|
Arguments :
|
|
<name> is the name of the agent section.
|
|
|
|
following keywords are supported :
|
|
- groups
|
|
- log
|
|
- maxconnrate
|
|
- maxerrrate
|
|
- max-frame-size
|
|
- max-waiting-frames
|
|
- messages
|
|
- [no] option async
|
|
- [no] option dontlog-normal
|
|
- [no] option pipelining
|
|
- [no] option send-frag-payload
|
|
- option continue-on-error
|
|
- option force-set-var
|
|
- option set-on-error
|
|
- option set-process-time
|
|
- option set-total-time
|
|
- option var-prefix
|
|
- register-var-names
|
|
- timeout hello|idle|processing
|
|
- use-backend
|
|
|
|
|
|
groups <grp-name> ...
|
|
Declare the list of SPOE groups that an agent will handle.
|
|
|
|
Arguments :
|
|
<grp-name> is the name of a SPOE group.
|
|
|
|
Groups declared here must be found in the same engine scope, else an error is
|
|
triggered during the configuration parsing. You can have many "groups" lines.
|
|
|
|
See also: "spoe-group" section.
|
|
|
|
|
|
log global
|
|
log <address> [len <length>] [format <format>] <facility> [<level> [<minlevel>]]
|
|
no log
|
|
Enable per-instance logging of events and traffic.
|
|
|
|
Prefix :
|
|
no should be used when the logger list must be flushed.
|
|
|
|
See the HAProxy Configuration Manual for details about this option.
|
|
|
|
maxconnrate <number>
|
|
Set the maximum number of connections per second to <number>. The SPOE will
|
|
stop to open new connections if the maximum is reached and will wait to
|
|
acquire an existing one. So it is important to set "timeout hello" to a
|
|
relatively small value.
|
|
|
|
|
|
maxerrrate <number>
|
|
Set the maximum number of errors per second to <number>. The SPOE will stop
|
|
its processing if the maximum is reached.
|
|
|
|
|
|
max-frame-size <number>
|
|
Set the maximum allowed size for frames exchanged between HAProxy and SPOA.
|
|
It must be in the range [256, tune.bufsize-4] (4 bytes are reserved for the
|
|
frame length). By default, it is set to (tune.bufsize-4).
|
|
|
|
max-waiting-frames <number>
|
|
Set the maximum number of frames waiting for an acknowledgement on the same
|
|
connection. This value is only used when the pipelinied or asynchronus
|
|
exchanges between HAProxy and SPOA are enabled. By default, it is set to 20.
|
|
|
|
messages <msg-name> ...
|
|
Declare the list of SPOE messages that an agent will handle.
|
|
|
|
Arguments :
|
|
<msg-name> is the name of a SPOE message.
|
|
|
|
Messages declared here must be found in the same engine scope, else an error
|
|
is triggered during the configuration parsing. You can have many "messages"
|
|
lines.
|
|
|
|
See also: "spoe-message" section.
|
|
|
|
|
|
option async
|
|
no option async
|
|
Enable or disable the support of asynchronus exchanges between HAProxy and
|
|
SPOA. By default, this option is enabled.
|
|
|
|
|
|
option continue-on-error
|
|
Do not stop the events processing when an error occurred on a stream.
|
|
|
|
By default, for a specific stream, when an abnormal/unexpected error occurs,
|
|
the SPOE is disabled for all the transaction. So if you have several events
|
|
configured, such error on an event will disabled all following. For TCP
|
|
streams, this will disable the SPOE for the whole session. For HTTP streams,
|
|
this will disable it for the transaction (request and response).
|
|
|
|
When set, this option bypass this behaviour and only the current event will
|
|
be ignored.
|
|
|
|
|
|
option dontlog-normal
|
|
no option dontlog-normal
|
|
Enable or disable logging of normal, successful processing.
|
|
|
|
Arguments : none
|
|
|
|
See also: "log" and section 4 about logging.
|
|
|
|
|
|
option force-set-var
|
|
By default, SPOE filter only register already known variables (mainly from
|
|
parsing of the configuration). If you want that haproxy trusts the agent and
|
|
registers all variables (ex: can be useful for LUA workload), activate this
|
|
option.
|
|
|
|
Caution : this option opens to a variety of attacks such as a rogue SPOA that
|
|
asks to register too many variables.
|
|
|
|
|
|
option pipelining
|
|
no option pipelining
|
|
Enable or disable the support of pipelined exchanges between HAProxy and
|
|
SPOA. By default, this option is enabled.
|
|
|
|
|
|
option send-frag-payload
|
|
no option send-frag-payload
|
|
Enable or disable the sending of fragmented payload to SPOA. By default, this
|
|
option is enabled.
|
|
|
|
|
|
option set-on-error <var name>
|
|
Define the variable to set when an error occurred during an event processing.
|
|
|
|
Arguments :
|
|
|
|
<var name> is the variable name, without the scope. The name may only
|
|
contain characters 'a-z', 'A-Z', '0-9', '.' and '_'.
|
|
|
|
This variable will only be set when an error occurred in the scope of the
|
|
transaction. As for all other variables define by the SPOE, it will be
|
|
prefixed. So, if your variable name is "error" and your prefix is
|
|
"my_spoe_pfx", the variable will be "txn.my_spoe_pfx.error".
|
|
|
|
When set, the variable is an integer representing the error reason. For values
|
|
under 256, it represents an error coming from the engine. Below 256, it
|
|
reports a SPOP error. In this case, to retrieve the right SPOP status code,
|
|
you must remove 256 to this value. Here are possible values:
|
|
|
|
* 1 a timeout occurred during the event processing.
|
|
|
|
* 2 an error was triggered during the resources allocation.
|
|
|
|
* 3 the frame payload exceeds the frame size and it cannot be
|
|
fragmented.
|
|
|
|
* 4 the fragmentation of a payload is aborted.
|
|
|
|
* 5 The frame processing has been interrupted by HAProxy.
|
|
|
|
* 255 an unknown error occurred during the event processing.
|
|
|
|
* 256+N a SPOP error occurred during the event processing (see section
|
|
"Errors & timeouts").
|
|
|
|
Note that if "option continue-on-error" is set, the variable is not
|
|
automatically removed between events processing.
|
|
|
|
See also: "option continue-on-error", "option var-prefix".
|
|
|
|
|
|
option set-process-time <var name>
|
|
Define the variable to set to report the processing time of the last event or
|
|
group.
|
|
|
|
Arguments :
|
|
|
|
<var name> is the variable name, without the scope. The name may only
|
|
contain characters 'a-z', 'A-Z', '0-9', '.' and '_'.
|
|
|
|
This variable will be set in the scope of the transaction. As for all other
|
|
variables define by the SPOE, it will be prefixed. So, if your variable name
|
|
is "process_time" and your prefix is "my_spoe_pfx", the variable will be
|
|
"txn.my_spoe_pfx.process_time".
|
|
|
|
When set, the variable is an integer representing the delay to process the
|
|
event or the group, in milliseconds. From the stream point of view, it is the
|
|
latency added by the SPOE processing for the last handled event or group.
|
|
|
|
If several events or groups are processed for the same stream, this value
|
|
will be overrideen.
|
|
|
|
See also: "option set-total-time".
|
|
|
|
|
|
option set-total-time <var name>
|
|
Define the variable to set to report the total processing time SPOE for a
|
|
stream.
|
|
|
|
Arguments :
|
|
|
|
<var name> is the variable name, without the scope. The name may only
|
|
contain characters 'a-z', 'A-Z', '0-9', '.' and '_'.
|
|
|
|
This variable will be set in the scope of the transaction. As for all other
|
|
variables define by the SPOE, it will be prefixed. So, if your variable name
|
|
is "total_time" and your prefix is "my_spoe_pfx", the variable will be
|
|
"txn.my_spoe_pfx.total_time".
|
|
|
|
When set, the variable is an integer representing the sum of processing times
|
|
for a stream, in milliseconds. From the stream point of view, it is the
|
|
latency added by the SPOE processing.
|
|
|
|
If several events or groups are processed for the same stream, this value
|
|
will be updated.
|
|
|
|
See also: "option set-process-time".
|
|
|
|
|
|
option var-prefix <prefix>
|
|
Define the prefix used when variables are set by an agent.
|
|
|
|
Arguments :
|
|
|
|
<prefix> is the prefix used to limit the scope of variables set by an
|
|
agent.
|
|
|
|
To avoid conflict with other variables defined by HAProxy, all variables
|
|
names will be prefixed. By default, the "spoe-agent" name is used. This
|
|
option can be used to customize it.
|
|
|
|
The prefix will be added between the variable scope and its name, separated
|
|
by a '.'. It may only contain characters 'a-z', 'A-Z', '0-9', '.' and '_', as
|
|
for variables name. In HAProxy configuration, you need to use this prefix as
|
|
a part of the variables name. For example, if an agent define the variable
|
|
"myvar" in the "txn" scope, with the prefix "my_spoe_pfx", then you should
|
|
use "txn.my_spoe_pfx.myvar" name in your HAProxy configuration.
|
|
|
|
By default, an agent will never set new variables at runtime: It can only set
|
|
new value for existing ones. If you want a different behaviour, see
|
|
force-set-var option and register-var-names directive.
|
|
|
|
register-var-names <var name> ...
|
|
Register some variable names. By default, an agent will not be allowed to set
|
|
new variables at runtime. This rule can be totally relaxed by setting the
|
|
option "force-set-var". If you know all the variables you will need, this
|
|
directive is a good way to register them without letting an agent doing what
|
|
it want. This is only required if these variables are not referenced anywhere
|
|
in the HAProxy configuration or the SPOE one.
|
|
|
|
Arguments:
|
|
<var name> is a variable name without the scope. The name may only
|
|
contain characters 'a-z', 'A-Z', '0-9', '.' and '_'.
|
|
|
|
The prefix will be automatically added during the registration. You can have
|
|
many "register-var-names" lines.
|
|
|
|
See also: "option force-set-var", "option var-prefix".
|
|
|
|
timeout hello <timeout>
|
|
Set the maximum time to wait for an agent to receive the AGENT-HELLO frame.
|
|
It is applied on the stream that handle the connection with the agent.
|
|
|
|
Arguments :
|
|
<timeout> is the timeout value specified in milliseconds by default, but
|
|
can be in any other unit if the number is suffixed by the unit,
|
|
as explained at the top of this document.
|
|
|
|
This timeout is an applicative timeout. It differ from "timeout connect"
|
|
defined on backends.
|
|
|
|
|
|
timeout idle <timeout>
|
|
Set the maximum time to wait for an agent to close an idle connection. It is
|
|
applied on the stream that handle the connection with the agent.
|
|
|
|
Arguments :
|
|
<timeout> is the timeout value specified in milliseconds by default, but
|
|
can be in any other unit if the number is suffixed by the unit,
|
|
as explained at the top of this document.
|
|
|
|
|
|
timeout processing <timeout>
|
|
Set the maximum time to wait for a stream to process an event, i.e to acquire
|
|
a stream to talk with an agent, to encode all messages, to send the NOTIFY
|
|
frame, to receive the corrsponding acknowledgement and to process all
|
|
actions. It is applied on the stream that handle the client and the server
|
|
sessions.
|
|
|
|
Arguments :
|
|
<timeout> is the timeout value specified in milliseconds by default, but
|
|
can be in any other unit if the number is suffixed by the unit,
|
|
as explained at the top of this document.
|
|
|
|
|
|
use-backend <backend>
|
|
Specify the backend to use. It must be defined.
|
|
|
|
Arguments :
|
|
<backend> is the name of a valid "backend" section.
|
|
|
|
|
|
2.3. "spoe-message" section
|
|
----------------------------
|
|
|
|
To offload the stream processing, SPOE will send messages with specific
|
|
information at a specific moment in the stream life and will wait for
|
|
corresponding replies to know what to do.
|
|
|
|
|
|
spoe-message <name>
|
|
Create a new SPOE message with the name <name>.
|
|
|
|
Arguments :
|
|
<name> is the name of the SPOE message.
|
|
|
|
Here you define a message that can be referenced in a "spoe-agent"
|
|
section. Following keywords are supported :
|
|
- acl
|
|
- args
|
|
- event
|
|
|
|
See also: "spoe-agent" section.
|
|
|
|
|
|
acl <aclname> <criterion> [flags] [operator] <value> ...
|
|
Declare or complete an access list.
|
|
|
|
See section 7 about ACL usage in the HAProxy Configuration Manual.
|
|
|
|
|
|
args [name=]<sample> ...
|
|
Define arguments passed into the SPOE message.
|
|
|
|
Arguments :
|
|
<sample> is a sample expression.
|
|
|
|
When the message is processed, if a sample expression is not available, it is
|
|
set to NULL. Arguments are processed in their declaration order and added in
|
|
the message in that order. It is possible to declare named arguments.
|
|
|
|
For example:
|
|
args frontend=fe_id src dst
|
|
|
|
|
|
event <name> [ { if | unless } <condition> ]
|
|
Set the event that triggers sending of the message. It may optionally be
|
|
followed by an ACL-based condition, in which case it will only be evaluated
|
|
if the condition is true.
|
|
|
|
ACL-based conditions are executed in the context of the stream that handle
|
|
the client and the server connections.
|
|
|
|
Arguments :
|
|
<name> is the event name.
|
|
<condition> is a standard ACL-based condition.
|
|
|
|
Supported events are:
|
|
- on-client-session
|
|
- on-server-session
|
|
- on-frontend-tcp-request
|
|
- on-backend-tcp-request
|
|
- on-tcp-response
|
|
- on-frontend-http-request
|
|
- on-backend-http-request
|
|
- on-http-response
|
|
|
|
See section "Events & Messages" for more details about supported events.
|
|
See section 7 about ACL usage in the HAProxy Configuration Manual.
|
|
|
|
2.4. "spoe-group" section
|
|
--------------------------
|
|
|
|
This section can be used to declare a group of SPOE messages. Unlike messages
|
|
referenced in a "spoe-agent" section, messages inside a group are not sent on a
|
|
specific event. The sending must be triggered by TCP or HTTP rules, from the
|
|
HAProxy configuration.
|
|
|
|
|
|
spoe-group <name>
|
|
Create a new SPOE group with the name <name>.
|
|
|
|
Arguments :
|
|
<name> is the name of the SPOE group.
|
|
|
|
Here you define a group of SPOE messages that can be referenced in a
|
|
"spoe-agent" section. Following keywords are supported :
|
|
- messages
|
|
|
|
See also: "spoe-agent" and "spoe-message" sections.
|
|
|
|
|
|
messages <msg-name> ...
|
|
Declare the list of SPOE messages belonging to the group.
|
|
|
|
Arguments :
|
|
<msg-name> is the name of a SPOE message.
|
|
|
|
Messages declared here must be found in the same engine scope, else an error
|
|
is triggered during the configuration parsing. Furthermore, a message belongs
|
|
at most to a group. You can have many "messages" lines.
|
|
|
|
See also: "spoe-message" section.
|
|
|
|
|
|
2.5. Example
|
|
-------------
|
|
|
|
Here is a simple but complete example that sends client-ip address to a ip
|
|
reputation service. This service can set the variable "ip_score" which is an
|
|
integer between 0 and 100, indicating its reputation (100 means totally safe
|
|
and 0 a blacklisted IP with no doubt).
|
|
|
|
###
|
|
### HAProxy configuration
|
|
frontend www
|
|
mode http
|
|
bind *:80
|
|
|
|
filter spoe engine ip-reputation config spoe-ip-reputation.conf
|
|
|
|
# Reject connection if the IP reputation is under 20
|
|
tcp-request content reject if { var(sess.iprep.ip_score) -m int lt 20 }
|
|
|
|
default_backend http-servers
|
|
|
|
backend http-servers
|
|
mode http
|
|
server http A.B.C.D:80
|
|
|
|
backend iprep-servers
|
|
mode tcp
|
|
balance roundrobin
|
|
|
|
timeout connect 5s # greater than hello timeout
|
|
timeout server 3m # greater than idle timeout
|
|
|
|
server iprep1 A1.B1.C1.D1:12345
|
|
server iprep2 A2.B2.C2.D2:12345
|
|
|
|
####
|
|
### spoe-ip-reputation.conf
|
|
[ip-reputation]
|
|
|
|
spoe-agent iprep-agent
|
|
messages get-ip-reputation
|
|
|
|
option var-prefix iprep
|
|
|
|
timeout hello 2s
|
|
timeout idle 2m
|
|
timeout processing 10ms
|
|
|
|
use-backend iprep-servers
|
|
|
|
spoe-message get-ip-reputation
|
|
args ip=src
|
|
event on-client-session if ! { src -f /etc/haproxy/whitelist.lst }
|
|
|
|
|
|
3. SPOP specification
|
|
----------------------
|
|
|
|
3.1. Data types
|
|
----------------
|
|
|
|
Here is the bytewise representation of typed data:
|
|
|
|
TYPED-DATA : <TYPE:4 bits><FLAGS:4 bits><DATA>
|
|
|
|
Supported types and their representation are:
|
|
|
|
TYPE | ID | DESCRIPTION
|
|
-----------------------------+-----+----------------------------------
|
|
NULL | 0 | NULL : <0>
|
|
Boolean | 1 | BOOL : <1+FLAG>
|
|
32bits signed integer | 2 | INT32 : <2><VALUE:varint>
|
|
32bits unsigned integer | 3 | UINT32 : <3><VALUE:varint>
|
|
64bits signed integer | 4 | INT64 : <4><VALUE:varint>
|
|
32bits unsigned integer | 5 | UNIT64 : <5><VALUE:varint>
|
|
IPV4 | 6 | IPV4 : <6><STRUCT IN_ADDR:4 bytes>
|
|
IPV6 | 7 | IPV6 : <7><STRUCT IN_ADDR6:16 bytes>
|
|
String | 8 | STRING : <8><LENGTH:varint><BYTES>
|
|
Binary | 9 | BINARY : <9><LENGTH:varint><BYTES>
|
|
10 -> 15 unused/reserved | - | -
|
|
-----------------------------+-----+----------------------------------
|
|
|
|
Variable-length integer (varint) are encoded using Peers encoding:
|
|
|
|
|
|
0 <= X < 240 : 1 byte (7.875 bits) [ XXXX XXXX ]
|
|
240 <= X < 2288 : 2 bytes (11 bits) [ 1111 XXXX ] [ 0XXX XXXX ]
|
|
2288 <= X < 264432 : 3 bytes (18 bits) [ 1111 XXXX ] [ 1XXX XXXX ] [ 0XXX XXXX ]
|
|
264432 <= X < 33818864 : 4 bytes (25 bits) [ 1111 XXXX ] [ 1XXX XXXX ]*2 [ 0XXX XXXX ]
|
|
33818864 <= X < 4328786160 : 5 bytes (32 bits) [ 1111 XXXX ] [ 1XXX XXXX ]*3 [ 0XXX XXXX ]
|
|
...
|
|
|
|
For booleans, the value (true or false) is the first bit in the FLAGS
|
|
bitfield. if this bit is set to 0, then the boolean is evaluated as false,
|
|
otherwise, the boolean is evaluated as true.
|
|
|
|
3.2. Frames
|
|
------------
|
|
|
|
Exchange between HAProxy and agents are made using FRAME packets. All frames
|
|
must be prefixed with their size encoded on 4 bytes in network byte order:
|
|
|
|
<FRAME-LENGTH:4 bytes> <FRAME>
|
|
|
|
A frame always starts with its type, on one byte, followed by metadata
|
|
containing flags, on 4 bytes and a two variable-length integer representing the
|
|
stream identifier and the frame identifier inside the stream:
|
|
|
|
FRAME : <FRAME-TYPE:1 byte> <METADATA> <FRAME-PAYLOAD>
|
|
METADATA : <FLAGS:4 bytes> <STREAM-ID:varint> <FRAME-ID:varint>
|
|
|
|
Then comes the frame payload. Depending on the frame type, the payload can be
|
|
of three types: a simple key/value list, a list of messages or a list of
|
|
actions.
|
|
|
|
FRAME-PAYLOAD : <LIST-OF-MESSAGES> | <LIST-OF-ACTIONS> | <KV-LIST>
|
|
|
|
LIST-OF-MESSAGES : [ <MESSAGE-NAME> <NB-ARGS:1 byte> <KV-LIST> ... ]
|
|
MESSAGE-NAME : <STRING>
|
|
|
|
LIST-OF-ACTIONS : [ <ACTION-TYPE:1 byte> <NB-ARGS:1 byte> <ACTION-ARGS> ... ]
|
|
ACTION-ARGS : [ <TYPED-DATA>... ]
|
|
|
|
KV-LIST : [ <KV-NAME> <KV-VALUE> ... ]
|
|
KV-NAME : <STRING>
|
|
KV-VALUE : <TYPED-DATA>
|
|
|
|
FLAGS :
|
|
|
|
Flags are a 32 bits field. They are encoded on 4 bytes in network byte
|
|
order, where the bit 0 is the LSB.
|
|
|
|
0 1 2-31
|
|
+---+---+----------+
|
|
| | A | |
|
|
| F | B | |
|
|
| I | O | RESERVED |
|
|
| N | R | |
|
|
| | T | |
|
|
+---+---+----------+
|
|
|
|
FIN: Indicates that this is the final payload fragment. The first fragment
|
|
may also be the final fragment.
|
|
|
|
ABORT: Indicates that the processing of the current frame must be
|
|
cancelled. This bit should be set on frames with a fragmented
|
|
payload. It can be ignore for frames with an unfragemnted
|
|
payload. When it is set, the FIN bit must also be set.
|
|
|
|
|
|
Frames cannot exceed a maximum size negotiated between HAProxy and agents
|
|
during the HELLO handshake. Most of time, payload will be small enough to send
|
|
it in one frame. But when supported by the peer, it will be possible to
|
|
fragment huge payload on many frames. This ability is announced during the
|
|
HELLO handshake and it can be asynmetric (supported by agents but not by
|
|
HAProxy or the opposite). The following rules apply to fragmentation:
|
|
|
|
* An unfragemnted payload consists of a single frame with the FIN bit set.
|
|
|
|
* A fragemented payload consists of several frames with the FIN bit clear and
|
|
terminated by a single frame with the FIN bit set. All these frames must
|
|
share the same STREAM-ID and FRAME-ID. The first frame must set the right
|
|
FRAME-TYPE (e.g, NOTIFY). The following frames must have an unset type (0).
|
|
|
|
Beside the support of fragmented payload by a peer, some payload must not be
|
|
fragmented. See below for details.
|
|
|
|
IMPORTANT : The maximum size supported by peers for a frame must be greater
|
|
than or equal to 256 bytes.
|
|
|
|
3.2.1. Frame capabilities
|
|
--------------------------
|
|
|
|
Here are the list of official capabilities that HAProxy and agents can support:
|
|
|
|
* fragmentation: This is the ability for a peer to support fragmented
|
|
payload in received frames. This is an asymmectical
|
|
capability, it only concerns the peer that announces
|
|
it. This is the responsibility to the other peer to use it
|
|
or not.
|
|
|
|
* pipelining: This is the ability for a peer to decouple NOTIFY and ACK
|
|
frames. This is a symmectical capability. To be used, it must
|
|
be supported by HAproxy and agents. Unlike HTTP pipelining, the
|
|
ACK frames can be send in any order, but always on the same TCP
|
|
connection used for the corresponding NOTIFY frame.
|
|
|
|
* async: This ability is similar to the pipelining, but here any TCP
|
|
connection established between HAProxy and the agent can be used to
|
|
send ACK frames. if an agent accepts connections from multiple
|
|
HAProxy, it can use the "engine-id" value to group TCP
|
|
connections. See details about HAPROXY-HELLO frame.
|
|
|
|
Unsupported or unknown capabilities are silently ignored, when possible.
|
|
|
|
NOTE: HAProxy does not support the fragmentation for now. This means it is not
|
|
able to handle fragmented frames. However, if an agent announces the
|
|
fragmentation support, HAProxy may choose to send fragemented frames.
|
|
|
|
3.2.2. Frame types overview
|
|
----------------------------
|
|
|
|
Here are types of frame supported by SPOE. Frames sent by HAProxy come first,
|
|
then frames sent by agents :
|
|
|
|
TYPE | ID | DESCRIPTION
|
|
-----------------------------+-----+-------------------------------------
|
|
UNSET | 0 | Used for all frames but the first when a
|
|
| | payload is fragmented.
|
|
-----------------------------+-----+-------------------------------------
|
|
HAPROXY-HELLO | 1 | Sent by HAProxy when it opens a
|
|
| | connection on an agent.
|
|
| |
|
|
HAPROXY-DISCONNECT | 2 | Sent by HAProxy when it want to close
|
|
| | the connection or in reply to an
|
|
| | AGENT-DISCONNECT frame
|
|
| |
|
|
NOTIFY | 3 | Sent by HAProxy to pass information
|
|
| | to an agent
|
|
-----------------------------+-----+-------------------------------------
|
|
AGENT-HELLO | 101 | Reply to a HAPROXY-HELLO frame, when
|
|
| | the connection is established
|
|
| |
|
|
AGENT-DISCONNECT | 102 | Sent by an agent just before closing
|
|
| | the connection
|
|
| |
|
|
ACK | 103 | Sent to acknowledge a NOTIFY frame
|
|
-----------------------------+-----+-------------------------------------
|
|
|
|
Unknown frames may be silently skipped.
|
|
|
|
3.2.3. Workflow
|
|
----------------
|
|
|
|
* Successful HELLO handshake:
|
|
|
|
HAPROXY AGENT SRV
|
|
| HAPROXY-HELLO |
|
|
| (healthcheck: false) |
|
|
| --------------------------> |
|
|
| |
|
|
| AGENT-HELLO |
|
|
| <-------------------------- |
|
|
| |
|
|
|
|
* Successful HELLO healthcheck:
|
|
|
|
HAPROXY AGENT SRV
|
|
| HAPROXY-HELLO |
|
|
| (healthcheck: true) |
|
|
| --------------------------> |
|
|
| |
|
|
| AGENT-HELLO + close() |
|
|
| <-------------------------- |
|
|
| |
|
|
|
|
|
|
* Error encountered by agent during the HELLO handshake:
|
|
|
|
HAPROXY AGENT SRV
|
|
| HAPROXY-HELLO |
|
|
| --------------------------> |
|
|
| |
|
|
| DISCONNECT + close() |
|
|
| <-------------------------- |
|
|
| |
|
|
|
|
* Error encountered by HAProxy during the HELLO handshake:
|
|
|
|
HAPROXY AGENT SRV
|
|
| HAPROXY-HELLO |
|
|
| --------------------------> |
|
|
| |
|
|
| AGENT-HELLO |
|
|
| <-------------------------- |
|
|
| |
|
|
| DISCONNECT |
|
|
| --------------------------> |
|
|
| |
|
|
| DISCONNECT + close() |
|
|
| <-------------------------- |
|
|
| |
|
|
|
|
* Notify / Ack exchange (unfragmented payload):
|
|
|
|
HAPROXY AGENT SRV
|
|
| NOTIFY |
|
|
| --------------------------> |
|
|
| |
|
|
| ACK |
|
|
| <-------------------------- |
|
|
| |
|
|
|
|
* Notify / Ack exchange (fragmented payload):
|
|
|
|
HAPROXY AGENT SRV
|
|
| NOTIFY (frag 1) |
|
|
| --------------------------> |
|
|
| |
|
|
| UNSET (frag 2) |
|
|
| --------------------------> |
|
|
| ... |
|
|
| UNSET (frag N) |
|
|
| --------------------------> |
|
|
| |
|
|
| ACK |
|
|
| <-------------------------- |
|
|
| |
|
|
|
|
* Aborted fragmentation of a NOTIFY frame:
|
|
|
|
HAPROXY AGENT SRV
|
|
| ... |
|
|
| UNSET (frag X) |
|
|
| --------------------------> |
|
|
| |
|
|
| ACK/ABORT |
|
|
| <-------------------------- |
|
|
| |
|
|
| UNSET (frag X+1) |
|
|
| -----------X |
|
|
| |
|
|
| |
|
|
|
|
* Connection closed by haproxy:
|
|
|
|
HAPROXY AGENT SRV
|
|
| DISCONNECT |
|
|
| --------------------------> |
|
|
| |
|
|
| DISCONNECT + close() |
|
|
| <-------------------------- |
|
|
| |
|
|
|
|
* Connection closed by agent:
|
|
|
|
HAPROXY AGENT SRV
|
|
| DISCONNECT + close() |
|
|
| <-------------------------- |
|
|
| |
|
|
|
|
3.2.4. Frame: HAPROXY-HELLO
|
|
----------------------------
|
|
|
|
This frame is the first one exchanged between HAProxy and an agent, when the
|
|
connection is established. The payload of this frame is a KV-LIST. It cannot be
|
|
fragmented. STREAM-ID and FRAME-ID are must be set 0.
|
|
|
|
Following items are mandatory in the KV-LIST:
|
|
|
|
* "supported-versions" <STRING>
|
|
|
|
Last SPOP major versions supported by HAProxy. It is a comma-separated list
|
|
of versions, following the format "Major.Minor". Spaces must be ignored, if
|
|
any. When a major version is announced by HAProxy, it means it also support
|
|
all previous minor versions.
|
|
|
|
Example: "2.0, 1.5" means HAProxy supports SPOP 2.0 and 1.0 to 1.5
|
|
|
|
* "max-frame-size" <UINT32>
|
|
|
|
This is the maximum size allowed for a frame. The HAPROXY-HELLO frame must
|
|
be lower or equal to this value.
|
|
|
|
* "capabilities" <STRING>
|
|
|
|
This a comma-separated list of capabilities supported by HAProxy. Spaces
|
|
must be ignored, if any.
|
|
|
|
Following optional items can be added in the KV-LIST:
|
|
|
|
* "healthcheck" <BOOLEAN>
|
|
|
|
If this item is set to TRUE, then the HAPROXY-HELLO frame is sent during a
|
|
SPOE health check. When set to FALSE, this item can be ignored.
|
|
|
|
* "engine-id" <STRING>
|
|
|
|
This is a uniq string that identify a SPOE engine.
|
|
|
|
To finish the HELLO handshake, the agent must return an AGENT-HELLO frame with
|
|
its supported SPOP version, the lower value between its maximum size allowed
|
|
for a frame and the HAProxy one and capabilities it supports. If an error
|
|
occurs or if an incompatibility is detected with the agent configuration, an
|
|
AGENT-DISCONNECT frame must be returned.
|
|
|
|
3.2.5. Frame: AGENT-HELLO
|
|
--------------------------
|
|
|
|
This frame is sent in reply to a HAPROXY-HELLO frame to finish a HELLO
|
|
handshake. As for HAPROXY-HELLO frame, STREAM-ID and FRAME-ID are also set
|
|
0. The payload of this frame is a KV-LIST and it cannot be fragmented.
|
|
|
|
Following items are mandatory in the KV-LIST:
|
|
|
|
* "version" <STRING>
|
|
|
|
This is the SPOP version the agent supports. It must follow the format
|
|
"Major.Minor" and it must be lower or equal than one of major versions
|
|
announced by HAProxy.
|
|
|
|
* "max-frame-size" <UINT32>
|
|
|
|
This is the maximum size allowed for a frame. It must be lower or equal to
|
|
the value in the HAPROXY-HELLO frame. This value will be used for all
|
|
subsequent frames.
|
|
|
|
* "capabilities" <STRING>
|
|
|
|
This a comma-separated list of capabilities supported by agent. Spaces must
|
|
be ignored, if any.
|
|
|
|
At this time, if everything is ok for HAProxy (supported version and valid
|
|
max-frame-size value), the HELLO handshake is successfully completed. Else,
|
|
HAProxy sends a HAPROXY-DISCONNECT frame with the corresponding error.
|
|
|
|
If "healthcheck" item was set to TRUE in the HAPROXY-HELLO frame, the agent can
|
|
safely close the connection without DISCONNECT frame. In all cases, HAProxy
|
|
will close the connection at the end of the health check.
|
|
|
|
3.2.6. Frame: NOTIFY
|
|
---------------------
|
|
|
|
Information are sent to the agents inside NOTIFY frames. These frames are
|
|
attached to a stream, so STREAM-ID and FRAME-ID must be set. The payload of
|
|
NOTIFY frames is a LIST-OF-MESSAGES and, if supported by agents, it can be
|
|
fragmented.
|
|
|
|
NOTIFY frames must be acknowledge by agents sending an ACK frame, repeating
|
|
right STREAM-ID and FRAME-ID.
|
|
|
|
3.2.7. Frame: ACK
|
|
------------------
|
|
|
|
ACK frames must be sent by agents to reply to NOTIFY frames. STREAM-ID and
|
|
FRAME-ID found in a NOTIFY frame must be reuse in the corresponding ACK
|
|
frame. The payload of ACK frames is a LIST-OF-ACTIONS and, if supported by
|
|
HAProxy, it can be fragmented.
|
|
|
|
3.2.8. Frame: HAPROXY-DISCONNECT
|
|
---------------------------------
|
|
|
|
If an error occurs, at anytime, from the HAProxy side, a HAPROXY-DISCONNECT
|
|
frame is sent with information describing the error. HAProxy will wait an
|
|
AGENT-DISCONNECT frame in reply. All other frames will be ignored. The agent
|
|
must then close the socket.
|
|
|
|
The payload of this frame is a KV-LIST. It cannot be fragmented. STREAM-ID and
|
|
FRAME-ID are must be set 0.
|
|
|
|
Following items are mandatory in the KV-LIST:
|
|
|
|
* "status-code" <UINT32>
|
|
|
|
This is the code corresponding to the error.
|
|
|
|
* "message" <STRING>
|
|
|
|
This is a textual message describing the error.
|
|
|
|
For more information about known errors, see section "Errors & timeouts"
|
|
|
|
3.2.9. Frame: AGENT-DISCONNECT
|
|
-------------------------------
|
|
|
|
If an error occurs, at anytime, from the agent size, a AGENT-DISCONNECT frame
|
|
is sent, with information describing the error. such frame is also sent in reply
|
|
to a HAPROXY-DISCONNECT. The agent must close the socket just after sending
|
|
this frame.
|
|
|
|
The payload of this frame is a KV-LIST. It cannot be fragmented. STREAM-ID and
|
|
FRAME-ID are must be set 0.
|
|
|
|
Following items are mandatory in the KV-LIST:
|
|
|
|
* "status-code" <UINT32>
|
|
|
|
This is the code corresponding to the error.
|
|
|
|
* "message" <STRING>
|
|
|
|
This is a textual message describing the error.
|
|
|
|
For more information about known errors, see section "Errors & timeouts"
|
|
|
|
3.3. Events & Messages
|
|
-----------------------
|
|
|
|
Information about streams are sent in NOTIFY frames. You can specify which kind
|
|
of information to send by defining "spoe-message" sections in your SPOE
|
|
configuration file. for each "spoe-message" there will be a message in a NOTIFY
|
|
frame when the right event is triggered.
|
|
|
|
A NOTIFY frame is sent for an specific event when there is at least one
|
|
"spoe-message" attached to this event. All messages for an event will be added
|
|
in the same NOTIFY frame.
|
|
|
|
Here is the list of supported events:
|
|
|
|
* on-client-session is triggered when a new client session is created.
|
|
This event is only available for SPOE filters
|
|
declared in a frontend or a listen section.
|
|
|
|
* on-frontend-tcp-request is triggered just before the evaluation of
|
|
"tcp-request content" rules on the frontend side.
|
|
This event is only available for SPOE filters
|
|
declared in a frontend or a listen section.
|
|
|
|
* on-backend-tcp-request is triggered just before the evaluation of
|
|
"tcp-request content" rules on the backend side.
|
|
This event is skipped for SPOE filters declared
|
|
in a listen section.
|
|
|
|
* on-frontend-http-request is triggered just before the evaluation of
|
|
"http-request" rules on the frontend side. This
|
|
event is only available for SPOE filters declared
|
|
in a frontend or a listen section.
|
|
|
|
* on-backend-http-request is triggered just before the evaluation of
|
|
"http-request" rules on the backend side. This
|
|
event is skipped for SPOE filters declared in a
|
|
listen section.
|
|
|
|
* on-server-session is triggered when the session with the server is
|
|
established.
|
|
|
|
* on-tcp-response is triggered just before the evaluation of
|
|
"tcp-response content" rules.
|
|
|
|
* on-http-response is triggered just before the evaluation of
|
|
"http-response" rules.
|
|
|
|
|
|
The stream processing will loop on these events, when triggered, waiting the
|
|
agent reply.
|
|
|
|
3.4. Actions
|
|
-------------
|
|
|
|
An agent must acknowledge each NOTIFY frame by sending the corresponding ACK
|
|
frame. Actions can be added in these frames to dynamically take action on the
|
|
processing of a stream.
|
|
|
|
Here is the list of supported actions:
|
|
|
|
* set-var set the value for an existing variable. 3 arguments must be
|
|
attached to this action: the variable scope (proc, sess, txn,
|
|
req or res), the variable name (a string) and its value.
|
|
|
|
ACTION-SET-VAR : <SET-VAR:1 byte><NB-ARGS:1 byte><VAR-SCOPE:1 byte><VAR-NAME><VAR-VALUE>
|
|
|
|
SET-VAR : <1>
|
|
NB-ARGS : <3>
|
|
VAR-SCOPE : <PROCESS> | <SESSION> | <TRANSACTION> | <REQUEST> | <RESPONSE>
|
|
VAR-NAME : <STRING>
|
|
VAR-VALUE : <TYPED-DATA>
|
|
|
|
PROCESS : <0>
|
|
SESSION : <1>
|
|
TRANSACTION : <2>
|
|
REQUEST : <3>
|
|
RESPONSE : <4>
|
|
|
|
* unset-var unset the value for an existing variable. 2 arguments must be
|
|
attached to this action: the variable scope (proc, sess, txn,
|
|
req or res) and the variable name (a string).
|
|
|
|
ACTION-UNSET-VAR : <UNSET-VAR:1 byte><NB-ARGS:1 byte><VAR-SCOPE:1 byte><VAR-NAME>
|
|
|
|
UNSET-VAR : <2>
|
|
NB-ARGS : <2>
|
|
VAR-SCOPE : <PROCESS> | <SESSION> | <TRANSACTION> | <REQUEST> | <RESPONSE>
|
|
VAR-NAME : <STRING>
|
|
|
|
PROCESS : <0>
|
|
SESSION : <1>
|
|
TRANSACTION : <2>
|
|
REQUEST : <3>
|
|
RESPONSE : <4>
|
|
|
|
|
|
NOTE: Name of the variables will be automatically prefixed by HAProxy to avoid
|
|
name clashes with other variables used in HAProxy. Moreover, unknown
|
|
variable will be silently ignored.
|
|
|
|
3.5. Errors & timeouts
|
|
----------------------
|
|
|
|
Here is the list of all known errors:
|
|
|
|
STATUS CODE | DESCRIPTION
|
|
----------------+--------------------------------------------------------
|
|
0 | normal (no error occurred)
|
|
1 | I/O error
|
|
2 | A timeout occurred
|
|
3 | frame is too big
|
|
4 | invalid frame received
|
|
5 | version value not found
|
|
6 | max-frame-size value not found
|
|
7 | capabilities value not found
|
|
8 | unsupported version
|
|
9 | max-frame-size too big or too small
|
|
10 | payload fragmentation is not supported
|
|
11 | invalid interlaced frames
|
|
12 | frame-id not found (it does not match any referenced frame)
|
|
13 | resource allocation error
|
|
99 | an unknown error occurrde
|
|
----------------+--------------------------------------------------------
|
|
|
|
An agent can define its own errors using a not yet assigned status code.
|
|
|
|
IMPORTANT NOTE: By default, for a specific stream, when an abnormal/unexpected
|
|
error occurs, the SPOE is disabled for all the transaction. So
|
|
if you have several events configured, such error on an event
|
|
will disabled all following. For TCP streams, this will
|
|
disable the SPOE for the whole session. For HTTP streams, this
|
|
will disable it for the transaction (request and response).
|
|
See 'option continue-on-error' to bypass this limitation.
|
|
|
|
To avoid a stream to wait undefinetly, you must carefully choose the
|
|
acknowledgement timeout. In most of cases, it will be quiet low. But it depends
|
|
on the responsivness of your service.
|
|
|
|
You must also choose idle timeout carefully. Because connection with your
|
|
service depends on the backend configuration used by the SPOA, it is important
|
|
to use a lower value for idle timeout than the server timeout. Else the
|
|
connection will be closed by HAProxy. The same is true for hello timeout. You
|
|
should choose a lower value than the connect timeout.
|
|
|
|
4. Logging
|
|
-----------
|
|
|
|
Activity of an SPOE is logged using HAProxy's logger. The messages are logged
|
|
in the context of the streams that handle the client and the server
|
|
connections. A message is emitted for each event or group handled by an
|
|
SPOE. Depending on the status code, the log level will be different. In the
|
|
normal case, when no error occurred, the message is logged with the level
|
|
LOG_NOTICE. Otherwise, the message is logged with the level LOG_WARNING.
|
|
|
|
The messages are logged using the agent's logger, if defined, and use the
|
|
following format:
|
|
|
|
SPOE: [AGENT] <TYPE:NAME> sid=STREAM-ID st=STATUS-CODE reqT/qT/wT/resT/pT \
|
|
<idles>/<applets> <nb_sending>/<nb_waiting> <nb_error>/<nb_processed>
|
|
|
|
AGENT is the agent name
|
|
TYPE is EVENT of GROUP
|
|
NAME is the event or the group name
|
|
STREAM-ID is an integer, the unique id of the stream
|
|
STATUS_CODE is the processing's status code
|
|
reqT/qT/wT/resT/pT are the following time events:
|
|
|
|
* reqT : the encoding time. It includes ACLs processing, if any. For
|
|
fragmented frames, it is the sum of all fragments.
|
|
* qT : the delay before the request gets out the sending queue. For
|
|
fragmented frames, it is the sum of all fragments.
|
|
* wT : the delay before the response is received. No fragmentation
|
|
supported here.
|
|
* resT : the delay to process the response. No fragmentation supported
|
|
here.
|
|
* pT : the delay to process the event or the group. From the stream
|
|
point of view, it is the latency added by the SPOE processing.
|
|
It is more or less the sum of values above.
|
|
|
|
<idle> is the numbers of idle SPOE applets
|
|
<applets> is the numbers of SPOE applets
|
|
<nb_sending> is the numbers of streams waiting to send data
|
|
<nb_waiting> is the numbers of streams waiting for a ack
|
|
<nb_error> is the numbers of processing errors
|
|
<nb_processed> is the numbers of events/groups processed
|
|
|
|
|
|
For all these time events, -1 means the processing was interrupted before the
|
|
end. So -1 for the queue time means the request was never dequeued. For
|
|
fragmented frames it is harder to know when the interruption happened.
|
|
|
|
/*
|
|
* Local variables:
|
|
* fill-column: 79
|
|
* End:
|
|
*/
|