This is the multi-page printable view of this section. Click here to print.
Advanced features
1 - Content popularity
ESB3024 Router allows routing decisions based on content popularity. All incoming content requests are tracked to continuously update a content popularity ranking list. The popularity ranking algorithm is designed to let popular content quickly rise to the top while unpopular content decays and sinks towards the bottom.
Configuration
All configuration parameters for content popularity reside in the
settings
object of the configuration, an example of which can be
seen below:
{
"settings": {
"content_popularity": {
"algorithm": "scored_based",
"session_group_names": ["vod_only"],
"score_based:": {
"requests_between_popularity_decay": 1000,
"popularity_list_max_size": 100000,
"popularity_prediction_factor": 2.5,
"popularity_decay_fraction": 0.2
},
"time_based": {
"intervals_per_hour": 10
}
}
}
}
The field algorithm
dictates which content popularity tracking
algorithm to use, can either be score_based
or time_based
.
The field session_group_names
defines the sessions for which content
popularity should be tracked. In the example above, session belonging to
the vod_only
session group will be tracked for content popularity.
If left empty, content popularity will be tracked for all sessions.
The remaining configuration parameters are algorithm specific.
Score based algorithm
The field popularity_list_max_size
defines
the maximum amount of unique contents to track for popularity. This can
be used to limit memory growth. A single entry in the popularity ranking
list will at most consume 180 B of memory, giving an upper bound memory
growth of \(180n_{\text{requests}}\) bytes. E.g. using
"popularity_list_max_size": 1000
would consume at most
180⋅1,000 = 180,000 B = 0.18 MB. If the content popularity list is full,
a request to unique content would replace the least popular content.
Setting a very high max size won’t impact performance, it will only consume more memory.
The field requests_between_popularity_decay
defines the number of requests
between each popularity decay update, an integral component of this feature.
The fields popularity_prediction_factor
and popularity_decay_fraction
tune
the behaviour of the content popularity ranking algorithm, explained further
below.
Decay update
To allow for popular content to quickly rise in popularity and unpopular content to sink, a dynamic popularity ranking algorithm is used. The goal of the algorithm is to track content popularity in real time, allowing routing decisions based on the requested content’s popularity. The algorithm is applied every decay update.
The algorithm uses current trending content to predict content popularity. The
field popularity_prediction_factor
regulates how much the algorithm should rely
on predicted popularity. A high prediction factor allows rising content to quickly
rise to high popularity but can also cause unpopular content with a sudden burst
of requests to wrongfully rise to the top. A low prediction factor can cause
stagnation in the popularity ranking, not allowing new popular content to rise
to the top.
Unpopular content decays in popularity, the magnitude of which is regulated by
popularity_decay_fraction
. A high value will aggressively decay content popularity
every decay update while a low value will bloat the ranking, causing stagnation.
Once content decays to a trivially low popularity score, it is pruned from the
content popularity list.
When configuring these tuning parameters, the most crucial data to consider is
the size of your asset catalog, i.e. the number of unique contents you offer.
The recommended values, obtained through testing, are presented in the table below.
Note that the field popularity_prediction_factor
is the principal factor in
controlling the algorithm’s behaviour.
Catalog size \(n\) | popularity_prediction_factor | popularity_decay_fraction |
---|---|---|
\(n\) < 1000 | 2.2 | 0.2 |
1000 < \(n\) < 5000 | 2.3 | 0.2 |
5000 < \(n\) < 10000 | 2.5 | 0.2 |
\(n\) > 10000 | 2.6 | 0.2 |
Time based algorithm
The time based algorithm only requires the configuration parameter
intervals_per_hour
. E.g., the value "intervals_per_hour": 10
would give 10 six minute intervals per hour. During each interval,
all unique content requests has an associated counter, increasing
by one for each incoming request. After an hour, all intervals have
been cycled through. The counters in the first interval will be reset
and all incoming content requests will increase the counters in the
first interval again. This cycle continues forever.
When determining a single content’s popularity, the sum of each content’s counter in all intervals is used to determine a popularity ranking.
Usage in routing
Content popularity ranking is available in Lua through the simple member
session.content_global_popularity
, returning the requested content’s
popularity ranking. E.g., the routing configuration below will route all
requests to content with a popularity ranking lower than 10, i.e. top 10
most popular content, to the host edge-streamer while requests to
content outside of the top 10 most popular will be routed to the host offload.
"routing": {
"id": "routing_table",
"member_order": "sequential",
"members": [
{
"id": "edge",
"weight_function": "return session.content_global_popularity < 11 and 1 or 0",
"host_id": "edge-streamer"
},
{
"id": "offload",
"weight_function": "return 1",
"host_id": "offload"
}
]
}
2 - Consistent Hashing
Consistent hashing based routing is a feature that can be used to distribute requests to a set of hosts in a cache friendly manner. By using Agile Content’s consistent distributed hash algorithm, the amount of cache redistribution is minimized within a set of hosts. Requests for a content will always be routed to the same set of hosts, the amount of which is configured by the spread factor, allowing high cache usage. When adding or removing hosts, the algorithm minimizes cache redistribution.
Say you have the host group [s1, s2, s3, s4, s5]
and have
configured spreadFactor = 3
. A request for a content asset1
would then be
routed to the same three hosts with one of them being selected randomly for each
request. Requests for a different content asset2
would also be routed to one
of three different hosts, most likely a different combination of hosts than
requests for content asset1
.
Example routing results with spreadFactor = 3
:
- Request for
asset1
→ route to one of[s1, s3, s4]
. - Request for
asset2
→ route to one of[s2, s4, s5]
. - Request for
asset3
→ route to one of[s1, s2, s5]
.
Since consistent hashing based routing ensures that requests for a specific content always get routed to the same set of hosts, the risk of cache misses are lowered on the hosts since they will be served the same content requests over and over again.
Note that the maximum value of
spreadFactor
is 64. Consequently, the highest amount of hosts you can use in aconsistentHashing
rule block is 64.
Configuration
Configuring consistent hashing based routing is easily done using confcli. Let’s configure the example described above:
confcli services.routing.rules -w
Running wizard for resource 'rules'
Hint: Hitting return will set a value to its default.
Enter '?' to receive the help string
rules : [
rule can be one of
1: allow
2: consistentHashing
3: contentPopularity
4: deny
5: firstMatch
6: random
7: rawGroup
8: rawHost
9: split
10: weighted
Choose element index or name: consistentHashing
Adding a 'consistentHashing' element
rule : {
name (default: ): consistentHashingRule
type (default: consistentHashing):
spreadFactor (default: 1): 3
targets : [
target : {
target (default: ): s1
enabled (default: True):
}
Add another 'target' element to array 'targets'? [y/N]: y
target : {
target (default: ): s2
enabled (default: True):
}
Add another 'target' element to array 'targets'? [y/N]: y
target : {
target (default: ): s3
enabled (default: True):
}
Add another 'target' element to array 'targets'? [y/N]: y
target : {
target (default: ): s4
enabled (default: True):
}
Add another 'target' element to array 'targets'? [y/N]: y
target : {
target (default: ): s5
enabled (default: True):
}
Add another 'target' element to array 'targets'? [y/N]: n
]
}
Add another 'rule' element to array 'rules'? [y/N]: n
]
Generated config:
{
"rules": [
{
"name": "consistentHashingRule",
"type": "consistentHashing",
"spreadFactor": 3,
"targets": [
{
"target": "s1",
"enabled": true
},
{
"target": "s2",
"enabled": true
},
{
"target": "s3",
"enabled": true
},
{
"target": "s4",
"enabled": true
},
{
"target": "s5",
"enabled": true
}
]
}
]
}
Adding hosts
Adding a host to the list will give an additional target for the consistent hashing algorithm to route requests to. This will shift content distribution onto the new host.
confcli services.routing.rules.consistentHashingRule.targets -w
Running wizard for resource 'targets'
Hint: Hitting return will set a value to its default.
Enter '?' to receive the help string
targets : [
target : {
target (default: ): s6
enabled (default: True):
}
Add another 'target' element to array 'targets'? [y/N]: n
]
Generated config:
{
"targets": [
{
"target": "s6",
"enabled": true
}
]
}
Merge and apply the config? [y/n]: y
Removing hosts
There is one very important caveat of using a consistent hashing rule block. As long as you don’t modify the list of hosts, the consistent hashing algorithm will keep routing requests to the same hosts. However, if you remove a host from the block in any position except the last, the consistent hashing algorithm’s behaviour will change and the algorithm cannot maintain a minimum amount of cache redistribution.
If you’re in a situation where you have to remove a host from the routing
targets but want to keep the same consistent hashing behaviour, e.g. during
very high load, you’ll have to toggle that target’s enabled
field to false
.
E.g., disabling requests to s2
can be accomplished by:
$ confcli services.routing.rules.consistentHashingRule.targets.1.enabled false
services.routing.rules.consistentHashingRule.targets.1.enabled = False
$ confcli services.routing.rules.consistentHashingRule.targets.1
{
"1": {
"target": "s2",
"enabled": false
}
}
If you modify the list order or remove hosts, it is highly recommended to do so during moments where a higher rate of cache misses are acceptable.
3 - Predictive load balancing
Why use predictive load balancing?
Predictive load balancing is a tool that can be used to avoid overloading hosts with traffic. Consider the case where a popular event starts at a certain time, let’s say 12 PM. A spike in traffic will be routed to the hosts that are streaming the content at 12 PM, most of them starting at low bitrates. A host might have sufficient bandwidth left to take on more clients but when the recently connected clients start ramping up in video quality and increase their bitrate, the host can quickly become overloaded, possibly dropping incoming requests or going offline. Predictive load balancing solves this issue by considering how many times a host recently been redirected to.
Basic configuration
The router allows predicting incoming load for individual hosts. Through the use of the selection input API, the routing engine can predict incoming load by tracking recent host selections and make routing decisions accordingly.
What is considered recent is configurable and defaults to 500 milliseconds:
$ confcli services.routing.tuning.target.recentDurationMilliseconds
{
"recentDurationMilliseconds": 500
}
$ confcli services.routing.tuning.target.recentDurationMilliseconds 1000
services.routing.tuning.target.recentDurationMilliseconds = 1000
{
"tuning": {
"target_recent_duration_milliseconds": 500
}
}
How to use predictive load balancing
The standard Lua library provides four functions for predictive load balancing
that can be used when constructing conditions/weight functions: host_bitrate()
, host_bitrate_custom()
, host_has_bw()
and host_has_bw_custom()
.
All require data to be supplied to the selection input API and apply
only to leaf nodes in the routing tree. In order for predictive load balancing
to work properly the data must be updated at regular intervals. The data needs
to be supplied by the target system.
These functions are suitable to used as host health checks. To configure host health checks, see configuring CDNs and hosts.
Note that host_bitrate()
and host_has_bw()
rely on data supplied by metrics
agents, detailed in Cache hardware metrics: monitoring and routing.
host_bitrate_custom()
and host_has_bw_custom()
rely on
manually supplied selection input data, detailed in selection input API. The
bitrate unit depends on the data submitted to the selection input API.
host_bitrate()
host_bitrate()
returns the predicted bitrate (in megabits per second) of
the host after the recently connected clients start ramping up in streaming
quality. The function accepts up to four arguments:
interface
: The name of the interface to use for bitrate prediction.- Optional
avg_bitrate
: the average bitrate per client, defaults to 6 megabits per second. - Optional
num_routers
: the number of routers that can route to this host, defaults to 1. This is important to accurately predict the incoming load if multiple routers are used. - Optional
host
: The name of the host to use for bitrate prediction. Defaults to the current host if not provided.
Examples of usage:
host_bitrate({interface="eths0"})
host_bitrate({avg_bitrate=1, interface="eths0"})
host_bitrate({num_routers=2, interface="eths0"})
host_bitrate({avg_bitrate=1, num_routers=4, interface="eths0"})
host_bitrate({avg_bitrate=1, num_routers=4, host="custom_host", interface="eths0"})
host_bitrate()
calculates the predicted bitrate as:
predicted_host_bitrate = current_host_bitrate + (recent_connections * avg_bitrate * num_routers)
host_bitrate_custom()
Same functionality as host_bitrate()
but uses a custom selection input
variable as bitrate input instead of accessing hardware metrics. The function
accepts up to three arguments:
custom_bitrate_var
: The name of the selection input variable to be used for accessing current host bitrate.- Optional
avg_bitrate
: seehost_bitrate()
documentation above. - Optional
num_routers
: seehost_bitrate()
documentation above.
host_bitrate_custom({custom_bitrate_var="host1_current_bitrate"})
host_bitrate_custom({avg_bitrate=1, custom_bitrate_var="host1_current_bitrate"})
host_bitrate_custom({num_routers=4, custom_bitrate_var="host1_current_bitrate"})
host_has_bw()
Instead of accessing the predicted bitrate of a host through host_bitrate()
,
host_has_bw()
returns 1 if the host is predicted to have enough
bandwidth left to take on more clients after recent connections ramp up in
bitrate, otherwise it returns 0. The function accepts up to five arguments:
interface
: seehost_bitrate()
documentation above.- Optional
avg_bitrate
: seehost_bitrate()
documentation above. - Optional
num_routers
: seehost_bitrate()
documentation above. - Optional
host
: seehost_bitrate()
documentation above. - Optional
margin
: the bitrate (megabits per second) headroom that should be taken into account during calculation, defaults to 0.
host_has_bw()
returns whether or not the following statement is true:
predicted_host_bitrate + margin < host_bitrate_capacity
Examples of usage:
host_has_bw({interface="eths0"})
host_has_bw({margin=10, interface="eth0"})
host_has_bw({avg_bitrate=1, interface="eth0"})
host_has_bw({num_routers=4, interface="eth0"})
host_has_bw({host="custom_host", interface="eth0"})
host_has_bw_custom()
Same functionality as host_has_bw()
but uses a custom selection input
variable as bitrate and capacity input. The function accepts up to five
arguments:
custom_capacity_var
: the name of the selection input variable to be used for accessing host capacity.custom_bitrate_var
: seehost_bitrate_custom()
documentation- Optional
margin
: seehost_has_bw()
documentation above. above. - Optional
avg_bitrate
: seehost_bitrate()
documentation above. - Optional
num_routers
: seehost_bitrate()
documentation above.
Examples of usage:
host_has_bw_custom({custom_capacity_var="host1_capacity", custom_bitrate_var="host1_current_bitrate"})
host_has_bw_custom({margin=10, custom_capacity_var="host1_capacity", custom_bitrate_var="host1_current_bitrate"})
host_has_bw_custom({avg_bitrate=1, custom_capacity_var="host1_capacity", custom_bitrate_var="host1_current_bitrate"})
host_has_bw_custom({num_routers=4, custom_capacity_var="host1_capacity", custom_bitrate_var="host1_current_bitrate"})
Examples in routing
When using confcli
it’s not recommended to use host_bitrate()
since it’s not
possible to make comparisons using <
, >
or similar operators. Using
host_has_bw()
makes it easy to construct conditions utilizing predictive load
balancing.
host_has_bw()
and host_has_bw_custom()
are excellent candidates to be used
as health check functions for hosts, see configuring CDNs and hosts for more details.
$ confcli services.routing.rules -w
Running wizard for resource 'rules'
Hint: Hitting return will set a value to its default.
Enter '?' to receive the help string
rules : [
rule can be one of
1: allow
2: consistentHashing
3: contentPopularity
4: deny
5: firstMatch
6: random
7: rawGroup
8: rawHost
9: split
10: weighted
Choose element index or name: weighted
Adding a 'weighted' element
rule : {
name (default: ): weighted_and_has_bw
type (default: weighted):
targets : [
target : {
target (default: ): host1
weight (default: 100):
condition (default: always()): host_has_bw({interface="eths0"})
}
Add another 'target' element to array 'targets'? [y/N]: y
target : {
target (default: ): host2
weight (default: 100): 100
condition (default: always()): host_has_bw({margin=1000, interface="eths0"})
}
Add another 'target' element to array 'targets'? [y/N]: y
target : {
target (default: ): host3
weight (default: 100):
condition (default: always()): host_has_bw({avg_bitrate=1, num_routers=2, margin=5000, interface="eths0"})
}
Add another 'target' element to array 'targets'? [y/N]: n
]
}
Add another 'rule' element to array 'rules'? [y/N]: n
]
Generated config:
{
"rules": [
{
"name": "weighted_and_has_bw",
"type": "weighted",
"targets": [
{
"target": "host1",
"weight": "100",
"condition": "host_has_bw({interface="eths0"})"
},
{
"target": "host2",
"weight": "100",
"condition": "host_has_bw({margin=1000, interface="eths0"})"
},
{
"target": "host3",
"weight": "100",
"condition": "host_has_bw({avg_bitrate=1, num_routers=2, margin=5000, interface="eths0"})"
}
]
}
]
}
"routing": {
"id": "weighted_and_has_bw",
"member_order": "sorted",
"members": [
{
"id": "1",
"host_id": "host1",
"weight_function": "return host_bitrate({interface="eths0"}) > 0 and 1 or 0"
},
{
"id": "2",
"host_id": "host2",
"weight_function": "return host_bitrate({avg_bitrate=1, interface="eths0"}) > 10000 and 1 or 0"
},
{
"id": "3",
"host_id": "host3",
"weight_function": "return host_has_bw({avg_bitrate=1, num_routers=2, margin=5000, interface="eths0"}) and 1 or 0"
}
],
"weight_function": "return 1"
}
4 - Security token verification
The security token verification feature allows for ESB3024 Router to only process requests that contain a correct security token. The token is generated by the client, for example in the portal, using an algorithm that it shares with the router. The router verifies the token and rejects the request if the token is incorrect.
It is beyond the scope of this document to describe how the token is generated, that is described in the Security Tokens application note that is installed with the ESB3024 Router’s extra documentation.
Setting up a routing rule
The token verification is performed by calling the verify_security_token()
function from a routing rule. The function returns 1
if the token is
correct, otherwise it returns 0
. It should typically be called from the
first routing rule, to make requests with bad tokens fail as early as possible.
The confcli example assumes that the router already has rules configured, with
an entry point named select_cdn
. Token verification is enabled by inserting an
“allow” rule first in the rule list.
confcli services.routing.rules -w
Running wizard for resource 'rules'
Hint: Hitting return will set a value to its default.
Enter '?' to receive the help string
rules : [
rule can be one of
1: allow
2: consistentHashing
3: contentPopularity
4: deny
5: firstMatch
6: random
7: rawGroup
8: rawHost
9: split
10: weighted
Choose element index or name: allow
Adding a 'allow' element
rule : {
name (default: ): token_verification
type (default: allow):
condition (default: always()): verify_security_token()
onMatch (default: ): select_cdn
}
Add another 'rule' element to array 'rules'? [y/N]: n
]
Generated config:
{
"rules": [
{
"name": "token_verification",
"type": "allow",
"condition": "verify_security_token()",
"onMatch": "select_cdn"
}
]
}
Merge and apply the config? [y/n]: y
$ confcli services.routing.entrypoint token_verification
services.routing.entrypoint = 'token_verification'
"routing": {
"id": "token_verification",
"member_order": "sequential",
"members": [
{
"id": "token_verification.0.select_cdn",
"member_order": "weighted",
"members": [
...
],
"weight_function": "return verify_security_token() ~= 0"
},
{
"id": "token_verification.1.rejected",
"member_order": "sequential",
"members": [],
"weight_function": "return 1"
}
],
"weight_function": "return 100"
},
Configuring security token options
The secret
parameter is not part of the router request, but needs to be
configured separately in the router. That can be done with the host-config
tool that is installed with the router.
Besides configuring the secret, host-config
can also configure floating
sessions and a URL prefix. Floating sessions are sessions that are not tied to a
specific IP address. When that is enabled, the token verification will not take
the IP address into account when verifying the token.
The security token verification is configured per host, where a host is the name
of the host that the request was sent to. This makes it possible for a router to
support multiple customer accounts, each with their own secret. If no
configuration is found for a host, a configuration with the name default
is
used.
host-config
supports three commands: print
, set
and delete
.
The print
command prints the current configuration for a host. The following
parameters are supported:
host-config print [-n <host-name>]
By default it prints the configuration for all hosts, but if the optional -n
flag is given it will print the configuration for a single host.
Set
The set
command sets the configuration for a host. The configuration is given
as command line parameters. The following parameters are supported:
host-config set
-n <host-name>
[-f floating]
[-p url-prefix]
[-r <secret-to-remove>]
[-s <secret-to-add>]
-n <host-name>
- The name of the host to configure.-f floating
- A boolean option that specifies if floating sessions are accepted. The parameter accepts the valuestrue
andfalse
.-p url-prefix
- A URL prefix that is used for identifying requests that come from a certain account. This is not used when verifying tokens.-r <secret-to-remove>
- A secret that should be removed from the list of secrets.-s <secret-to-add>
- A secret that should be added to the list of secrets.
For example, to set the secret “secret-1” and enable floating sessions for the default host, the following command can be used:
host-config set -n default -s secret-1 -f true
The set
command only touches the configuration options that are mentioned on
the command line, so the following command line will add a second secret to the
default host without changing the floating session setting:
host-config set -n default -s secret-2
It is possible to set multiple secrets per host. This is useful when updating a secret, then both the old and the new secret can be valid during the transition period. After the transition period the old secret can be removed by typing:
host-config set -n default -r secret-1
Delete
The delete
command deletes the configuration for a host. It supports the
following parameters:
host-config delete -n <host-name>
For example, to delete the configuration for example.com
, the following
command can be used:
host-config delete -n example.com
Global options
host-config
also has a few global options. They are:
-k <security-key>
- The security key that is used when communicating with the router. This is normally retrieved automatically.-h
- Print a help message and exit.-r <router>
- The router to connect to. This default tolocalhost
, but can be changed to connect to a remote router.-v
- Verbose output, can be given multiple times.
Debugging security token verification
The security token verification only logs messages when the log level is set to
4 or higher. Then it will only log some errors. It is possible to enable more
verbose logging using the security-token-config
that is installed together
with the router.
When verbose logging is enabled, the router will log information about the token verification, including the configured token secrets, so it needs to be used with care.
The logged lines are prefixed with verify_security_token
.
The security-token-config
tool supports the commands print
and set
.
The print
command prints the current configuration. If nothing is configured
it will not print anything.
Set
The set
command sets the configuration. The following parameters are
supported:
security-token-config set
[-d <enabled>]
-d <enabled>
- A boolean option that specifies if debug logging should be enabled or not. The parameter accepts the valuestrue
andfalse
.
5 - Subnets API
ESB3024 Router provides utilities to quickly match clients into subnets. Any combination of IPv4 and IPv6 addresses can be used. To begin, a JSON file is needed, defining all subnets, e.g:
{
"255.255.255.255/24": "area1",
"255.255.255.255/16": "area2",
"255.255.255.255/8": "area3",
"90.90.1.3/16": "area4",
"5.5.0.4/8": "area5",
"2a02:2e02:9bc0::/48": "area6",
"2a02:2e02:9bc0::/32": "area7",
"2a02:2e02:9bc0::/16": "area8",
"2a02:2e02:9de0::/44": "combined_area",
"2a02:2e02:ada0::/44": "combined_area"
}
and PUT
it to the endpoint :5001/v1/subnets
or :5001/v2/subnets
, the
API version doesn’t matter for subnets:
curl -k -T subnets.json -H "Content-Type: application/json" https://router-host:5001/v1/subnets
Note that it is possible for several subnet CIDR strings to share the same label, effectively grouping them together.
This will load the subnets into the router which will then be usable within any
Lua functions, accessed from the request
and session
tables
respectively, e.g.
{
"routing": {
"id": "routing_table",
"member_order": "sequential",
"members": [
{
"id": "node1",
"host_id": "host1",
"weight_function": "return request.subnet == 'area1' and 1 or 0"
}
]
}
}
Subnet matching will use the client IP fetched from the request
or session
tables. When possible, the subnet with the longest matching subnet mask will
be chosen, i.e. 255.255.255.255/28
will be chosen over 255.255.255.255/24
.
If no matching subnets are found, the boolean value false
will be returned.
NOTE: To use booleans in strings in Lua, calling
tostring(bool)
is required. Therefore, since subnet lookup might
return false
, the subnet call should be wrapped as: tostring(session.subnet)
or tostring(requst.subnet)
.
Invalid ip-addresses will be omitted during subnet list construction accompanied by a message in the log displaying the invalid IP address.
6 - Lua Features
Detailed descriptions and examples of Lua features offered by ESB3024 Router.
6.1 - Health Check Functions
This section details built in Lua functions that are meant to be used for host health checks. Note that these functions rely on data supplied by metric agents detailed in Cache hardware metrics: monitoring and routing. Make sure cache hardware metrics are supplied to the router before using any of these functions.
cpu_load_ok()
Parameters
The function accepts an optional argument table with the following keys:
- Optional
hostname
: The name of the host. Defaults to the hostname of the selected host if not provided. - Optional
cpu_load5_limit
: The acceptable limit for the 5-minute CPU load. Defaults to 0.9 if not provided.
Returns
The function returns 1 if the five minute CPU load average is below their respective limits, and 0 otherwise.
Usage examples
cpu_load_ok()
cpu_load_ok({hostname = "custom_host"})
cpu_load_ok({cpu_load5_limit = 0.8})
cpu_load_ok({hostname = "custom_host", cpu_load5_limit = 0.8})
memory_usage_ok()
Parameters
The function accepts an optional argument table with the following keys:
- Optional
hostname
: The name of the host. Defaults to the hostname of the selected host if not provided. - Optional
memory_usage_limit
: The acceptable limit for the memory usage. Defaults to 0.9 if not provided.
Returns
The function returns 1 if the memory usage is below the limit, and 0 otherwise.
Usage examples
memory_usage_ok()
memory_usage_ok({hostname = "custom_host"})
memory_usage_ok({memory_usage_limit = 0.7})
memory_usage_ok({hostname = "custom_host", memory_usage_limit = 0.7})
interfaces_online()
Parameters
The function accepts an argument table with the following keys:
- Required
interfaces
: A string or a table of strings representing the network interfaces to check. - Optional
hostname
: The name of the host. Defaults to the hostname of the selected host if not provided.
Returns
The function returns 1 if all the specified interfaces are online, and 0 otherwise.
Usage examples
interfaces_online({interfaces = "eth0"})
interfaces_online({interfaces = {"eth0", "eth1"}})
interfaces_online({hostname = "custom_host", interfaces = "eth0"})
interfaces_online({hostname = "custom_host", interfaces = {"eth0", "eth1"}})
health_check()
Parameters
The function accepts an optional argument table with the following keys:
- Required
interfaces
: A string or a table of strings representing the network interfaces to check. - Optional
hostname
: The name of the host. Defaults to the hostname of the selected host if not provided. - Optional
cpu_load5_limit
: The acceptable limit for the 5-minute CPU load. Defaults to 0.9 if not provided. - Optional
memory_usage_limit
: The acceptable limit for the memory usage. Defaults to 0.9 if not provided.
Returns
The function returns 1 if all the specified interfaces are online, and 0 otherwise.
Usage examples
health_check({interfaces = "eths0"})
health_check({hostname = "custom_host", interfaces = "eths0"})
health_check({cpu_load5_limit = 0.7, memory_usage_limit = 0.8, interfaces = "eth0"})
health_check({hostname = "custom_host", cpu_load5_limit = 0.7, memory_usage_limit = 0.8, interfaces = {"eth0", "eth1"}})
6.2 - Request Translation Function
Specifies the body of a Lua function that inspects every incoming HTTP request and overwrites individual fields before further processing by the router.
Returns nil
when nothing is to be changed, or HTTPRequest(t)
where t
is a table with any of the following optional fields:
Method
- Description: Replaces the HTTP request method in the request being processed.
- Type:
string
- Example:
'GET'
,'POST'
Path
- Description: Replaces the request path in the request being processed.
- Type:
string
- Example:
'/mycontent/superman.m3u8'
ClientIp
- Description: Replaces client IP address in the request being processed.
- Type:
string
- Example:
'172.16.238.128'
Body
- Description: Replaces body in the request being processed.
- Type:
string
ornil
- Example:
'{"foo": "bar"}'
QueryParameters
- Description: Adds, removes or replaces individual query parameters in the request being processed.
- Type: nested
table
(indexed by number) representing an array of query parameters as{[1]='Name',[2]='Value'}
pairs that are added to the request being processed, or overwriting existing query parameters with colliding names. To remove a query parameter from the request, specifynil
as value, i.e.QueryParameters={..., {[1]='foo',[2]=nil} ...}
. Returning a query parameter with a name but no value, such asa
in the request'/index.m3u8?a&b=22'
is currently not supported.
Headers
- Description: Adds, removes or replaces individual headers in the request being processed.
- Type: nested
table
(indexed by number) representing an array of request headers as{[1]='Name',[2]='Value'}
pairs that are added to the request being processed, or overwriting existing request headers with colliding names. To remove a header from the request, specifynil
as value, i.e.Headers={..., {[1]='foo',[2]=nil} ...}
. Duplicate names are supported. A multi-value header such asFoo: bar1,bar2
is defined by specifyingHeaders={..., {[1]='foo',[2]='bar1'}, {[1]='foo',[2]='bar2'}, ...}
.
Example of a request_translation_function
body that sets the request path
to a hardcoded value and adds the hardcoded query parameter a=b
:
-- Statements go here
print('Setting hardcoded Path and QueryParameters')
return HTTPRequest({
Path = '/content.mpd',
QueryParameters = {
{'a','b'}
}
})
Arguments
The following (iterable) arguments will be known by the function:
QueryParameters
Type: nested
table
(indexed by number).Description: Array of query parameters as
{[1]='Name',[2]='Value'}
pairs that were present in the query string of the request. Format identical to theHTTPRequest.QueryParameters
-field specified for the return value above.Example usage:
for _, queryParam in pairs(QueryParameters) do print(queryParam[1]..'='..queryParam[2]) end
Headers
Type: nested
table
(indexed by number).Description: Array of request headers as
{[1]='Name',[2]='Value'}
pairs that were present in the request. Format identical to theHTTPRequest.Headers
-field specified for the return value above. A multi-value header such asFoo: bar1,bar2
is seen inrequest_translation_function
asHeaders={..., {[1]='foo',[2]='bar1'}, {[1]='foo',[2]='bar1'}, ...}
.Example usage:
for _, header in pairs(Headers) do print(header[1]..'='..header[2]) end
Global metatables
In addition to the arguments above, the following (non-iterable) global
metatables will be populated with fields that may be retrieved by the
request_translation_function
:
- Note that metatables may only be accessed by already known keys:
Metatable request
request.method
- Description: HTTP request method.
- Type:
string
- Example:
'GET'
,'POST'
request.body
- Description: HTTP request body string.
- Type:
string
ornil
- Example:
'{"foo": "bar"}'
request.major_version
- Description: Major HTTP version such as
x
inHTTP/x.1
. - Type:
integer
- Example:
1
- Description: Major HTTP version such as
request.minor_version
- Description: Minor HTTP version such as
x
inHTTP/1.x
. - Type:
integer
- Example:
1
- Description: Minor HTTP version such as
request.protocol
- Description: Transfer protocol variant.
- Type:
string
- Example:
'HTTP'
,'HTTPS'
request.client_ip
- Description: IP address of the client issuing the request.
- Type:
string
- Example:
'172.16.238.128'
request.path_with_query_params
- Description: Full request path including query parameters.
- Type:
string
- Example:
'/mycontent/superman.m3u8?b=y&c=z&a=x'
request.path
- Description: Request path without query parameters.
- Type:
string
- Example:
'/mycontent/superman.m3u8'
request.query_params
- Description: The query parameter string.
- Type:
string
- Example:
'b=y&c=z&a=x'
request.filename
- Description: The part of the path following the final slash, if any.
- Type:
string
- Example:
'superman.m3u8'
request.subnet
- Description: Subnet of
client_ip
. - Type:
string
ornil
- Example:
'all'
- Description: Subnet of
Metatable request_query_params
Contains the query parameters keyed by name.
Example:
print(request_query_params.a)
Metatable request_headers
Contains the request headers keyed by name.
Example:
print(request_headers.a)
Multiple values are separated with a comma.
Global tables
In addition to the (non-iterable) metatables and (iterable) arguments above, the following global iterable tables are available from all Lua functions:
Table selection_input
Contains arbitrary, custom fields fed into the router by clients. Be careful to document any dependencies between the translation functions and selection inputs.
Example usage:
if selection_input then
for k, v in pairs(selection_input) do
print('here is '..'selection_input!')
print(k..'='..v)
end
else
print('selection_input is nil')
end
Upon returning from request_translation_function
, values in the request
,
request_query_params
and request_headers
metatables will reflect
the new current status of the updated HTTP Request.
6.3 - Response Translation Function
Specifies the body of a Lua function that inspects every outgoing HTTP response and overwrites individual fields before being sent to the client.
Returns nil
when nothing is to be changed, or HTTPResponse(t)
where t
is a table with any of the following optional fields:
Code
- Description: Replaces status code in the response being sent.
- Type:
integer
- Example:
200
,404
Text
- Description: Replaces status text in the response being sent.
- Type:
string
- Example:
'OK'
,'Not found'
MajorVersion
- Description: Replaces major HTTP version such as
x
inHTTP/x.1
in the response being sent. - Type:
integer
- Example:
1
- Description: Replaces major HTTP version such as
MinorVersion
- Description: Replaces minor HTTP version such as
x
inHTTP/1.x
in the response being sent. - Type:
integer
- Example:
1
- Description: Replaces minor HTTP version such as
Protocol
- Description: Replaces protocol in the response being sent.
- Type:
string
- Example:
'HTTP'
,'HTTPS'
Body
- Description: Replaces body in the response being sent.
- Type:
string
ornil
- Example:
'{"foo": "bar"}'
Headers
- Description: Adds, removes or replaces individual headers in the response being sent.
- Type: nested
table
(indexed by number) representing an array of response headers as{[1]='Name',[2]='Value'}
pairs that are added to the response being sent, or overwriting existing request headers with colliding names. To remove a header from the response, specifynil
as value, i.e.Headers={..., {[1]='foo',[2]=nil} ...}
. Duplicate names are supported. A multi-value header such asFoo: bar1,bar2
is defined by specifyingHeaders={..., {[1]='foo',[2]='bar1'}, {[1]='foo',[2]='bar2'}, ...}
.
Example of a response_translation_function
body that sets the Location
header to a hardcoded value:
-- Statements go here
print('Setting hardcoded Location')
return HTTPResponse({
Headers = {
{'Location', 'cdn1.com/content.mpd?a=b'}
}
})
Arguments
The following (iterable) arguments will be known by the function:
Headers
Type: nested
table
(indexed by number).Description: Array of response headers as
{[1]='Name',[2]='Value'}
pairs that are present in the response being sent. Format identical to theHTTPResponse.Headers
-field specified for the return value above. A multi-value header such asFoo: bar1,bar2
is seen inresponse_translation_function
asHeaders={..., {[1]='foo',[2]='bar1'}, {[1]='foo',[2]='bar1'}, ...}
.Example usage:
for _, header in pairs(Headers) do print(header[1]..'='..header[2]) end
Global metatables
In addition to the arguments above, the following (non-iterable) global
metatables will be populated with fields that may be retrieved by the
response_translation_function
:
Note that metatables may only be accessed by already known keys.
Metatable request
See documentation for request_translation_function. If the
request translation function has modified the incoming request, the request
metatable will contain those changes.
Metatable request_query_params
See documentation for request_translation_function. If the request translation function has modified the incoming request, the
request_query_params
metatable will contain those changes.
Metatable session_query_params
Alias for metatable request_query_params
.
Metatable request_headers
See documentation for request_translation_function. If
the request translation function has modified the incoming request, the
request_headers
metatable will contain those changes.
Metatable response
Contains all the parts of the outgoing response apart from the headers.
response.body
- Description: HTTP response body string.
- Type:
string
ornil
- Example:
'{"foo": "bar"}'
response.code
- Description: HTTP response status code.
- Type:
integer
- Example:
200
,404
response.text
- Description: HTTP response status text.
- Type:
string
- Example:
'OK'
,'Not found'
response.major_version
- Description: Major HTTP version such as
x
inHTTP/x.1
. - Type:
integer
- Example:
1
- Description: Major HTTP version such as
response.minor_version
- Description: Minor HTTP version such as
x
inHTTP/1.x
. - Type:
integer
- Example:
1
- Description: Minor HTTP version such as
response.protocol
- Description: Transfer protocol variant.
- Type:
string
- Example:
'HTTP'
,'HTTPS'
Metatable response_headers
Contains the response headers keyed by name. Example:
print(response_headers.a)
Multiple values are separated with a comma.
Metatable session
See documentation for session_translation_function. If the
session translation function has modified the incoming request, the session
metatable will contain those changes.
Metatable session_groups
See documentation for session_translation_function.
Global tables
In addition to the (non-iterable) metatables and (iterable) arguments above, the following global iterable tables are available from all Lua functions:
Table selection_input
See documentation for request_translation_function. Values
in the selection_input
metatable will remain unchanged since a prior call to a
request_translation_function
.
6.4 - Session Translation Function
Specifies the body of a Lua function that inspects a newly created session and may override its suggested type from “initial” to “instream” or vice versa.
Returns nil
when the session type is to remain unchanged, or Session(t)
where t
is a table with a single field:
Type
- Description: New type of the session.
- Type:
string
- Example:
'instream'
,'initial'
Example of a session_translation_function
body that unconditionally makes
all sessions 'instream'
:
-- Statements go here
print('Modifying session type')
return Session({['Type'] = 'instream'})
Arguments
The following (iterable) arguments are passed to the function:
Type
- Description: The suggested type of the session.
- Type:
string
- Example:
'instream'
,'initial'
Example usage:
-- Flip session type
local newType = 'initial'
if Type == 'initial' then
newType = 'instream'
end
print('Changing session type from ' .. Type .. ' to ' .. newType)
return Session({['Type'] = newType})
Global metatables
In addition to the arguments above, the following (non-iterable) global metatables will be populated with fields that may be retrieved by the response translation function.
Metatable request
See documentation for request_translation_function. If the
request translation function has modified the incoming request, the request
metatable will contain those changes.
Metatable request_query_params
See documentation for request_translation_function. If the request translation function has modified the incoming request, the
request_query_params
metatable will contain those changes.
Metatable session_query_params
Alias for metatable request_query_params
.
Metatable request_headers
See documentation for request_translation_function. If
the request translation function has modified the incoming request, the
request_headers
metatable will contain those changes.
Metatable session
session.client_ip
- Description: Alias for
request.client_ip
. See documentation for request_translation_function.
- Description: Alias for
session.path_with_query_params
- Description: Alias for
request.path_with_query_params
. See documentation for request_translation_function.
- Description: Alias for
session.path
- Description: Alias for
request.path
. See documentation for request_translation_function.
- Description: Alias for
session.query_params
- Description: Alias for
request.query_params
. See documentation for request_translation_function.
- Description: Alias for
session.filename
- Description: Alias for
request.filename
. See documentation for request_translation_function.
- Description: Alias for
session.subnet
- Description: Alias for
request.subnet
. See documentation for request_translation_function.
- Description: Alias for
session.host
- Description: ID of the currently selected host for the session.
- Type:
string
ornil
- Example:
'host1'
session.id
- Description: ID of the session.
- Type:
string
- Example:
'8eb2c1bdc106-17d2ff-00000000'
session.session_type
- Description: Type of the session.
- Type:
string
- Example:
'initial'
or'instream'
. Identical to the value of theType
argument of the session translation function.
session.is_managed
- Description: Identifies managed sessions.
- Type:
boolean
- Example:
true
ifType
/session.session_type
is'instream'
Metatable session_groups
Defines a mapping from session group name to boolean
, indicating whether
the session belongs to the session group or not.
Example usage:
if session_groups.vod then print('vod') else print('not vod') end
or
if session_groups['vod'] then print('vod') else print('not vod') end
Global tables
In addition to the (non-iterable) metatables and (iterable) arguments above, the following global iterable tables are available from all Lua functions:
Table selection_input
See documentation for See documentation for request_translation_function.
Values in the selection_input
metatable will remain unchanged since a prior
call to a request_translation_function
.