Traffic Manager Functions

Traffic Manager TrafficScript functions provide the means to inspect, manipulate and direct traffic within the Traffic Manager.

The TrafficScript functions are grouped into several families:

Queries the named authenticator for information about "user" and, if supplied, checks that "password" matches the password on record for that user. Authenticators can be configured from the "Catalog > Authenticators" page of the Administration Server.

After looking up the user, this function will return a hash with the following values set:

Authenticators can be configured to provide information about the supplied user, for example the groups to which they belong. This information will also be contained in the hash returned by the auth.query() function.

Cannot be used in completion rules.

This function instructs the connection to cease any protocol-specific processing, and just forward data between the client and server. If no server has been selected at this point, a load-balancing decision will still be made as per the pool configuration.

After calling this function the rule will terminate and no further rules will be processed on this connection. This feature is not supported with HTTP/2. If this function is used on an HTTP/2 stream, it will instead close the stream with an error indicating that the client should retry using HTTP/1.1.

Cannot be used in completion rules.

This function checks to see if this connection will be queued due to backend connection or transaction limits. The function returns 1 if the connection is within configured maximum limits for the named pool ( See the max_connections_pernode and the max_transactions_per_node settings in Pool > Protocol Settings ). The function returns 0 if the connection will exceed the configured maximum limits and would be queued.

If the named pool does not exist, your traffic manager will log a warning message and a value of -1 will be returned.

Note that even if this function returns 1, another child process may use the last available slot before this connection is forwarded to a node.

Can only be used with TCP-based protocols.

Writes the provided data directly back to the client. After the data has been sent, the connection is closed.

Use of connection.close is deprecated for HTTP virtual servers. Use http.sendResponse with http.disableClientKeepalive instead.

The optional second argument specifies whether data should continue to be read in from the client after sending this response, and wait for it to close the connection. If set to 0, the connection will close immediately. If non-zero, the traffic manager will wait and read any remaining data from the connection before closing it.

The default behaviour is to wait, because some client software will not read a response until it has sent its entire request.

Cannot be used in completion rules.

For HTTP/2, stops processing the current request, and leaves the TCP connection established. For other protocols, immediately closes the current connection and stops processing rules. This is equivalent to the function call 'pool.use( "discard" )'.

Cannot be used in completion rules.

This function has been deprecated. Use instead response.getBandwidthClass().

Returns the current bandwidth class for the connection to the client, or an empty string if no class is set.

Returns a short string code describing the reason a particular transaction completed. A list of the existing codes is given below.

Obtain more detailed information about the reason a particular connection completed. The information is returned in a hash, with the following keys:

This function has been deprecated. Use instead request.get( [count] ).

Returns the first 'count' bytes of data provided by the client.

Warning: you can stall a connection by asking it to read more data than the remote client will provide. Combine this with connection.getDataLen() to reliably read data from a connection.

This function has been deprecated. Use instead request.getLength().

Returns the number of bytes of data already received from the client. This can be combined with connection.getData() to reliably read data from a connection without stalling if no data is available.

This function has been deprecated. Use instead request.getLine( [regex], [offset] ).

Returns a line of input data provided by the client. The line separator is '\n', and this is stripped off before returning the line. connection.getline() takes a single byte-count argument which indicates where to start scanning for a line; a value of '0' begins at the start, so returns the first line.

When connection.getline() returns, the variable $1 is updated to point to the start of the next line in the datastream.

You can iterate through the lines of input data by using $1 as the iterator variable.

Not available when the virtual server's internal protocol is 'generic streaming'.

This function has been deprecated. Use instead request.getLocalIP().

Returns the IP address that the client connected to, i.e. the address local to this machine.

This function has been deprecated. Use instead request.getLocalPort().

Returns the network port number that the client connected to. (e.g. port 80 is normal for a web server)

Returns an estimate of the amount of memory currently in use for this connection, in bytes. Memory is primarily used for buffering data, and the memory usage can be tuned using the various buffer size settings.

Returns the name of the back-end node that this request is connected to. If a back-end node has not been chosen, which is normally the case in request rules, it returns the empty string.

In a Response rule this function returns the name of the current Session Persistence class used for this connection, or whatever class has been set by a previous use of connection.setPersistence().

Returns the name of the pool that this request is connected to. If a pool has not been chosen, it returns the empty string.

Returns the client IP address if one is contained in a connection PROXY header sent by the client. A client IP address is contained only in headers of a TCP or UDP type.

Returns the client port if one is contained in a connection PROXY header sent by the client. A client port is contained only in headers of a TCP or UDP type.

Returns the protocol or type of the connection's PROXY header, if available. This is not necessarily the same as the protocol in use on the connection itself. If PROXY protocol support is enabled, the value returned will be one of "TCP4", "TCP6", "UDP4", "UDP6", "UNIX STREAM", "UNIX DATAGRAM", "LOCAL" or "UNKNOWN". If PROXY protocol support is disabled, the empty string will be returned.

Returns the server IP address if one is contained in a connection PROXY header sent by the client. A server IP address is contained only in headers of a TCP or UDP type.

Returns the server port if one is contained in a connection PROXY header sent by the client. A server port is contained only in headers of a TCP or UDP type.

Returns an array of strings that contain the data from each TLV of the given type that is included in the PROXY protocol version 2 data sent on the connection, if any. This requires that PROXY protocol support is enabled and that a valid PROXY protocol version 2 header was received on the connection. If PROXY protocol support is disabled, no PROXY protocol header was received on the connection, PROXY protocol version 1 was used for the connection, or no TLV of the given type was included in the PROXY protocol version 2 header, then an empty list is returned.

Returns the version number of the PROXY protocol in use on the connection, if available. If PROXY protocol support is enabled and a PROXY protocol header was sent by the client, the value returned will be either 1 or 2. If PROXY protocol support is disabled then 0 will be returned.

This function has been deprecated. Use instead request.getRemoteIP().

Returns the remote IP address of the client.

This function has been deprecated. Use instead request.getRemotePort().

Returns the remote port of the client's connection.

Returns the current service level class for the connection, or an empty string if no class is set.

Returns the name of the Virtual Server that the rule is running under.

This function has been deprecated. Use instead response.setBandwidthClass( name ).

Sets the bandwidth class for the current connection to the client. Providing an empty class name removes the bandwidth class from the connection. It returns zero if an error occurs (for example, if the bandwidth class does not exist), and 1 otherwise.

Cannot be used in completion rules.

This function has been deprecated. Use instead request.set( request data ).

Replaces the input data read from the client with the provided string.

This is a low-level routine that should be used with care. For protocols with their own higher-level protocol managers (e.g. HTTP), use the higher level routines to alter the input data (e.g. http.setHeader() and http.setBody()).

Cannot be used in completion rules.

This function has been deprecated. Use instead request.setIdempotent( resend ).

Marks a request as resendable or non-resendable.

An idempotent request has no detrimental side effects, so it can safely be attempted multiple times. A non-idempotent request has a side effect - for example, it may update a database, or initiate a purchase.

By default, all non-HTTP requests are marked as idempotent. If a back-end node fails to generate a correct response when a request is initially forwarded to it, your traffic manager will attempt to resend the request to another node.

connection.setIdempotent() can override this behaviour. If 'resend' is zero, this indicates that the request should only be attempted against one back-end node.

If 'resend' has a non-zero value, this indicates that if a request is made to a back-end node and a correct response is not received, your traffic manager should retry the request against another back-end node.

Note that a request cannot be resent once it has begun streaming data between the client and the node. Additionally, UDP connections cannot be marked as resendable (the UDP client application should handle failed UDP responses).

Cannot be used in completion rules.

Sets the Session Persistence class that will be used for the connection. This is used to override the default Session Persistence class that will be used once a Pool is selected.

If no parameter is given then the current Session Persistence class will be removed and the Pool's default session persistence class will be used for this connection.

Cannot be used in completion rules.

Sets the value of the Session Persistence key that is used by a Universal Session Persistence type class.

Setting the value to the empty string will remove any persistence key from the connection.

A Session Persistence class that uses Universal Session Persistence attempts to ensure that every connection that provides the same key is directed to the same back-end node.

This function has no effect if a different type of session persistence class is ultimately used.

Cannot be used in completion rules.

Sets the back-end node to be used by a NamedNode Persistence class.

A Session Persistence class that uses NamedNode Persistence will then ensure that this node will be used for the request. The node must be valid and exist in the Pool being used. If no port number is given, or if the port number is not valid, then if there is a node with a matching name, it will be used. For example, if the node 'web:80' is specified, but there is only a 'web:443', then that node will be used instead. This is to help share session persistence between different services on the same machine.

This function has no effect if a different type of session persistence class is ultimately used.

Cannot be used in completion rules.

Sets the service level class for the current connection. It returns zero if an error occurs (for example, if the service level class does not exist), and 1 otherwise

Cannot be used in completion rules.

Pauses processing of the current connection for the specified number of milliseconds. This can be used to rate-limit particular clients; for example, those asking for particular files, or from particular locations, or using particular user-agents.

Cannot be used in completion rules.

Returns the value that was previously stored with the given key using connection.data.set() in the current connection, or returns the empty string if no data was stored.

Stores a value for this connection, associating it with the provided key. The value can be retrieved later when processing the same connection, using connection.data.get(). Once the connection finishes, the value cannot be retrieved.

Cannot be used in completion rules.

Increments the numbered counter. These counters are readable via SNMP, and can be graphed on the Current Activity page on the Administration Server.

By default, the counter is incremented by one, but you can also supply an amount to increment the counter by. If a negative amount is supplied the counter is decremented, but please keep in mind that a decrement is indiscernible from a wrap-around.

Increments the numbered 64 bit counter. These counters are readable via SNMP, and can be graphed on the Current Activity page on the Administration Server. 64 bit counters exist in a separate name- and storage space from the 32 bit counters, i.e. they don't overlap in any way.

By default, the counter is incremented by one, but you can also supply an amount to increment the counter by. If a negative amount is supplied the counter is decremented, but please keep in mind that a decrement is indiscernible from a wrap-around. Also please note that the supplied increment amount is limited to signed 32 bit range even though the counter is 64 bit.

Returns the value that was previously stored with the given key using data.set(), or returns the empty string if no data was stored.

Values stored in this way are persistent; a value stored in one rule can later be retrieved by a different rule handling a different connection. Thus, a rule can maintain persistent state across connections.

Returns the amount of free space, in bytes, available for storing information with data.set().

If memory space is low, then data.reset() can be used to clear some or all of the entries from the storage. Alternatively, the upper limit on memory can be configured using trafficscript!data_size on the Global Settings page.

Returns an estimate of the amount of memory, in bytes, used by entries that have been stored by data.set().

This can be used to verify if a rule is storing excessive amounts of data, starving the host machine of memory.

Removes the value that was previously associated with the given key using data.set().

data.remove() returns 1 if the item did exist, or 0 if it was not found.

Removes some or all of the mappings created by data.set(). With no arguments, it removes all keys. With a single argument, it removes all keys that begin with the supplied string.

NOTE: Should you intend to delete a specific individual key, data.remove() is more suited to this task. It offers greater performance and also ensures there is no risk of accidentally deleting other keys that start with the same string.

Stores a value, associating it with the provided key. The value can be retrieved later using data.get(), even from a different rule or connection.

The value will be stored as a string, implicit conversion of floating point numbers to strings can cause some precision loss. You can convert a floating point number into a string with no precision loss using 'string.sprintf( "%f", $val )'. Arrays and hashes are serialised before storing and will be deserialised into their original form when retrieved with data.get().

To prevent memory problems, there is an upper limit on the amount of data that can be stored in the TrafficScript data storage. This means that the data.set() may fail. The upper limit can be configured using trafficscript!data_size on the Global Settings page.

data.set() returns true if the entry was stored, or false if there was no room.

Returns the value that was previously stored with the given key using data.local.set(), or returns the empty string if no data was stored.

Values stored in this way are persistent; a value stored in one rule can later be retrieved by a different rule handling a different connection as long as it is handled by the same child process. Thus, a rule can maintain persistent state across connections. The value can be different or non-existent on another child process.

data.local.get() and data.local.set() are useful for caching data where coherence is not required.

Returns the amount of free space, in bytes, available for storing information with data.local.set().

If memory space is low, then data.local.reset() can be used to clear some or all of the entries from the storage. Alternatively, the upper limit on memory can be configured using trafficscript!data_local_size on the Global Settings page.

Returns an estimate of the amount of memory, in bytes, used by entries that have been stored by data.local.set().

This can be used to verify if a rule is storing excessive amounts of data, starving the host machine of memory.

Removes the value that was previously associated with the given key using data.local.set().

data.local.remove() returns 1 if the item did exist, or 0 if it was not found.

Removes some or all of the mappings created by data.local.set(). With no arguments, it removes all keys. With a single argument, it removes all keys that begin with the supplied string.

NOTE: Should you intend to delete a specific individual key, data.local.remove() is more suited to this task. It offers greater performance and also ensures there is no risk of accidentally deleting other keys that start with the same string.

Stores a value, associating it with the provided key. The value can be retrieved later using data.local.get(), even from a different rule or connection processed by the same child process.

The value will be stored as a string, implicit conversion of floating point numbers to strings can cause some precision loss. You can convert a floating point number into a string with no precision loss using 'string.sprintf( "%f", $val )'. Arrays and hashes are serialised before storing and will be deserialised into their original form when retrieved with data.local.get().

To prevent memory problems, there is an upper limit on the amount of data that can be stored in the local TrafficScript data storage. This means that the data.local.set() may fail. The upper limit can be configured using trafficscript!data_local_size on the Global Settings page.

data.local.set() returns true if the entry was stored, or false if there was no room.

Triggers a Custom Event identified by the 'custom event name'. Actions can be associated with the Custom Event by configuring an Event Type to contain a Custom Event with the specified 'custom event name', and then associating that Event Type with an Action.

The 'custom event name' cannot contain '/' or control codes.

In addition to custom actions, a log message will be produced containing the eventid and the message.

Returns the city of the supplied IP address, or the empty string.

Returns the country name of the supplied IP address, or the empty string.

Returns the two-character country code of the supplied IP address, or the empty string.

Returns the distance in kilometres between two points on the earth's surface (identified by latitude and longitude), or -1 on error.

Returns the distance in miles between two points on the earth's surface (identified by latitude and longitude), or -1 on error.

Returns the distance in kilometres between the locations of two IP addresses. It will return -1 unless both locations can be found.

Returns the distance in miles between the locations of two IP addresses. It will return -1 unless both locations can be found.

Returns the decimal latitude of the supplied IP address, or the empty string if the location is unknown. This may be accurate to city, region or only country level: to find out, check whether geo.getCity() and geo.getRegion() return empty strings.

Returns the name of the location in which this traffic manager is based.

Note that traffic managers can be assigned to locations only when vTM Multi-Site Cluster Management is enabled. The following geo.* TrafficScript functions require the installation of a GeoIP database in order to produce a result: geo.getCountry geo.getCountryCode geo.getRegion geo.getRegionCode geo.getCity get.getTimezone geo.getLatitude geo.getLongitude This must be installed separately and kept up-to-date for both IPv4 and IPv6 addresses to resolve to location names and latitude/longitude answers. See the User Guide section "Global Load Balancing" for instructions on installing the GeoIP database.

Returns a hash containing the longitude and latitude of the location to which this request was sent.

Note that traffic managers can be assigned to locations only when vTM Multi-Site Cluster Management is enabled and locations can be assigned a latitude and longitude only when using the Global Load Balancing feature.

Returns the decimal longitude of the supplied IP address, or the empty string if the location is unknown. This may be accurate to city, region or only country level: to find out, check whether geo.getCity() and geo.getRegion() return empty strings.

Returns the region (e.g. US state) of the supplied IP address, or the empty string if the location is unknown or doesn't have a region.

Returns the region code (e.g. US state abbreviation) of the supplied IP address, or the empty string. The code for a given region may differ between software versions.

Returns the timezone of the supplied IP address, or the empty string.

Get the domain currently being processed.

This function can only be used in GLB service rules.

Get an array of the IPs associated with the domain currently being processed.

This function can only be used in GLB service rules.

Avoid the specified location when re-writing the DNS response for the current domain.

The effect of this is to narrow down the list of available locations to just those that are not avoided.

If a location is both preferred and avoided being preferred will take precedence. If all locations are avoided (and none preferred) the outcome of the balancing algorithm will be as if no preferences have been specified.

If the location is unknown, unconfigured, or dead this preference will have no effect on the balancing decision. (In these cases a warning event will be raised and logged.)

This function can only be used in GLB service rules.

Cannot be used in completion rules.

Get the load of the specified location for the specified service, or for the current service if no service is specified and the function is used in a GLB service rule.

If the location does not exist, or is not configured for the specified service, the function will return -1 and will print a warning to the event log.

A service must be specified if this function is used outside a GLB service rule.

Get the weight of the specified location, as configured for the Weighted Random load balancing algorithm for the specified service, or for the current service if no service is specified and the function is used in a GLB service rule.

If the service is not using the Weighted Random load balancing algorithm then the weight for all locations will be reported as 0.

If the location does not exist, or is not configured for the specified service, the function will return -1 and will print a warning to the event log.

A service must be specified if this function is used outside a GLB service rule.

Get the name of the current GLB service configuration.

This is the service that has been picked to handle the current domain. It is this service that will have specified that the rule be executed.

This function can only be used in GLB service rules.

Get the name of the traffic manager location calculated to be the closest to geographic location the client IP. Note that only live traffic manager locations are considered in this calculation.

If no nearest traffic manager location could be calculated the empty string is returned.

This function can only be used in GLB service rules. An up-to-date GeoIP database must be installed separately for this TrafficScript function to return meaningful data. See the User Guide section "Global Load Balancing" for instructions on installing the GeoIP database.

Do not consider the specified location when re-writing the DNS response for the current domain.

This removes the specified location from the list of available locations.

Multiple locations can be ignored, if all available locations are ignored it will be as if all locations are dead. Ignoring locations takes precedence over preferring locations.

If the location is unknown, unconfigured, or dead this preference will have no effect on the balancing decision. (In these cases a warning event will be raised and logged.)

This function can only be used in GLB service rules.

Cannot be used in completion rules.

Check if a location is live. A non-live location includes those for which monitors have failed, or those that are in the "draining" list for the specified service, or for the current service if no service is specified and the function is used in a GLB service rule.

The function returns 1 if the location is live, 0 if it isn't, and -1 if the location does not exist or is not configured for the current service.

A service must be specified if this function is used outside a GLB service rule.

Get an array of the domains the specified GLB service is configured to handle, or the domains that the current GLB service is configured to handle if no service is specified.

This function can only be used in GLB service rules unless the service parameter is specified.

Get a priority-ordered array of the locations configured for the specified GLB service, or the current GLB service if none is specified. This is the value of the "location_order" config key.

This function can only be used in GLB service rules unless the service parameter is specified.

Prefer the specified location when re-writing the DNS response for the current domain. More than one location may be preferred by calling this function multiple times.

The effect of this is to narrow down the list of available locations to just those that have been selected as preferred. However, if no preferred locations are available balancing will fall back to other available locations.

If a location is both preferred and avoided being preferred will take precedence. If all locations are preferred the outcome of the balancing algorithm will be as if no preferences have been specified.

If the location is unknown, unconfigured, or dead this preference will have no effect on the balancing decision. (In these cases a warning event will be raised and logged.)

This function can only be used in GLB service rules.

Cannot be used in completion rules.

Skip the current service configuration. This means that no futher service rules will be executed and no balancing will occur for the domain currently being processed. The DNS records for the domain will be sent to the client unchanged. (Further A-record domains in the current DNS response may still be processed.)

The glb.service.skip() call does not return.

This function can only be used in GLB service rules.

Cannot be used in completion rules.

Force use of the specified location when re-writing the DNS response for the current domain.

If the location has IPs configured for the current service that match IPs returned in the DNS response for the current domain the response will be re-written to use only the IPs configured for the location.

If the location is unknown, unconfigured, or dead this preference will have no effect on the balancing decision. (In these cases a warning event will be raised and logged.)

This function can only be used in GLB service rules.

Cannot be used in completion rules.

Modifies the current HTTP request, adding an HTTP header with the supplied value. A case-insensitive lookup is first performed in order to find any existing headers. If a match is found, a duplicate header will be added to the message along with the new value.

If an invalid header name is specified, the function will print a warning and return without modifying the HTTP request.

Adds an HTTP header to the HTTP response that will be sent back to the client. If the header already exists in the response, then this value will be appended to the existing value. The header lookup is case-insensitive.

If an invalid header name is specified, the function will print a warning and return without modifying the HTTP response.

Redirect users to a new website. It is a more sophisticated version of http.redirect() that will preserve the original path that the request asked for. Note that it sends back a HTTP 301 redirect rather than the 302 response returned by http.redirect(). For instance, if the original request was for "http://www.example.com/image/image.jpg", then http.changeSite( "example.co.uk" ) would redirect the user to "http://example.co.uk/image/image.jpg"

The redirection will preserve the original path (and any query string) of the request, together with the port number and protocol. If you wish to force any of these details, then you can specify them as part of the supplied host name. e.g. http.changeSite( "https://www.example.com" ) will always send people to a SSL-encrypted site.

You can also add on a prefix to the path of the URL, e.g. http.changeSite( "www.example.com/oldsite" ) would redirect a request for "http://www.example.com/missing/page.html" to "http://www.example.com/oldsite/missing/page.html".

If the original request matches the supplied redirection, then http.changeSite() will take no action and let the request continue. This ensures that no 'redirection loops' occur.

Cannot be used in completion rules.

This function has been deprecated. Use instead http.getCookie( name ).

Returns the value of the named cookie.

Overrides the 'keepalive' setting on the virtual server for the current request by adding a 'Connection: close' header to the response.

Cannot be used in completion rules.

Checks whether a form parameter is present, either in the URL query string, or if not found and the request is a POST, from the POST body data. It returns 1 if the parameter is present, and 0 if not.

This is useful when there are form parameters with no value, e.g a query string like 'foo=bar&stuff&x=y' - the 'stuff' parameter has no value, but is present.

Returns the body data of the request. HTTP clients use the body data for sending file uploads or for HTML form parameters.

If the optional 'count' parameter is supplied, http.getBody() will only read and return this number of bytes. If count is 0, http.getBody() returns the entire request.

If the request has no body, then this returns an empty string.

http.getBody() will work in a response rule only if the entire request was read before the request rules completed (for example, if another call to http.getBody() was made in a request rule). Otherwise, request data will have been streamed to the server and not cached. If the request data is not available, this function will return the empty string.

This function is not usable in response rules, as the body data of the request will no longer be accessible.

To read HTML form parameters, it is easier to use http.getFormParam() as that will work for GET and POST requests.

Cannot be used in completion rules.

Splits the body data of the HTTP request into individual lines and returns an array of the data.

If the optional 'count' parameter is supplied, http.getBodyLines() will only read and return this number of bytes. If count is 0, http.getBodyLines() returns the entire request.

If the request has no body, then this returns an empty array. This function is not usable in response rules, as the body data of the request will no longer be accessible.

To read HTML form parameters, it is easier to use http.getFormParams() as that will work for GET and POST requests.

Cannot be used in completion rules.

Returns the HTTP version in use by the client.

This function differs from http.getVersion() in that it returns the version of the HTTP request sent by the client, rather than that of the HTTP request the traffic manager will send to the back-end server.

As an example, if the client is using HTTP/2 but the traffic manager has converted the request to HTTP/1.1 before processing it, http.getClientVersion() will return "HTTP/2" whereas http.getVersion() will return "HTTP/1.1".

Returns the named cookie in the incoming HTTP request.

http.getCookie is a helper method that makes it easier to parse the HTTP Cookie header and extract the values of that particular cookie, rather than using http.getHeader() directly.

An HTTP 'Cookie' header can have multiple values, such as

Cookie: user-id=Joe; user-type=gold

http.getCookie( ... ) will retrieve the 'Cookie' header line and parse it, returning the value of the cookie. If the cookie does not exist, http.getCookie() will return the empty string.

Returns a hash containing the names of all the cookies in this request mapped to their values.

An HTTP 'Cookie' header can have multiple values, such as

Cookie: user-id=Joe; user-type=gold

http.getCookies() will retrieve the 'Cookie' header line and parse it, returning a hash mapping all the cookie names to their values.

Returns the %-decoded form parameter from the URL query string, or if not found and the request is a POST, from the POST body data.

If the parameter is provided twice, only the first will be returned, unless the optional separator is provided, in which case all matches will be returned, separated with this string.

This function has been deprecated. Use instead http.listFormParamNames().

Returns a list containing the names of all the form parameters present in the URL query string and, if the request is a POST, in the POST body data. The names are returned as a single string, separated by the string supplied to this function. If the same parameter appears multiple times in the request, it will only appear once in the list returned by this function.

Returns a hash mapping the names of all the form parameters present in the URL query string and, if the request is a POST, in the POST body data to their values. If the same parameter appears multiple times in the request then it will be mapped to an array of values in the hash that is returned by this function.

Returns the value of a named HTTP header in the HTTP request, or the empty string if the header does not exist or has an empty value. The lookup is case-insensitive.

This function has been deprecated. Use instead http.listHeaderNames().

Returns a list of all the headers that are present in the request.

The headers are returned as a single string, separated by spaces.

Returns a hash containing all the header names in the request mapped to their values.

Returns the HTTP Host header. This value is lowercased and has the port removed. Any trailing full stop is also removed. For example if the Host header is 'www.Example.com:80' then http.getHostHeader() returns 'www.example.com'.

Returns the HTTP method that was used to make the request, such as GET or POST.

Returns the specified data out of a multipart encoded HTTP request. The data contained in the part is returned on success, or "" if it doesn't exist for that part. $1 contains the Content Type of the part, and $2 contains the complete headers for that part.

Returns the %-decoded path in the HTTP request URL, stripping the query string if one was provided. If there is a leading scheme and authority prefix, this is removed as well, so the URL "http://www.example.com/content?page=44" will be returned as "/content". If a %-encoded value is found, which isn't valid hexadecimal (for example, %G), this isn't converted or removed, but instead the '%' character is replaced by a '_' character, since malformed %-encoded values could be used as part of a malicious attack to fool security checks against particular URLs.

Returns the %-decoded query string in the URL, or the empty string if no query string was provided.

Returns the raw (non %-decoded) query string in the URL, or the empty string if no query string was provided.

Returns the raw (non-decoded) URL data provided by the client in the first line of the HTTP request, after the method and before the HTTP version specifier.

The raw URL data includes both the path and query string if supplied and is not decoded. It may also contain the protocol and hostname if the client sent them. It could contain %-escaped characters that can be used to disguise the contents of the URL. Use http.getPath() or http.getQueryString() to return the %-decoded version of the path or query string.

This function could return raw urls of various forms including:

You can use http.normalizePath() on the path component to remove any '/../' or '/./' references.

In general it is better to use http.getPath() and http.getQueryString() to avoid the need to process the raw url.

Returns the full HTTP request and headers, but does not include any body data.

Returns the beginning of the HTTP response (the status line and the headers), up to but not including the empty line that separates the headers from the body. The returned string does not include any body data.

Returns the body of the HTTP response.

If the response has chunked transfer encoding this function will return the de-chunked body. Similarly if the response is gzip or deflate compressed the body will be returned uncompressed.

If the optional 'count' parameter is provided, http.getResponseBody() will read and return the first 'count' bytes of the response. If count is 0, http.getResponseBody() will return the entire response.

Cannot be used in completion rules.

Splits the body data of the HTTP request into individual lines and returns an array of the data.

If the response has chunked transfer encoding this function will return the de-chunked body. Similarly if the response is gzip or deflate compressed the body will be returned uncompressed.

If the optional 'count' parameter is provided, http.getResponseBodyLines() will read and return the first 'count' bytes of the response. If count is 0, http.getResponseBodyLines() will return the entire response.

Cannot be used in completion rules.

Returns the status code from the first line of the HTTP response.

Returns the value of the named cookie in the HTTP response.

http.getResponseCookie() is a helper method to make it easier to parse the HTTP Set-Cookie header and extract the values of that particular cookie, rather than using http.getResponseHeader() directly.

If the cookie does not exist, http.getResponseCookie() will return the empty string.

This function should be called in a response rule; it has no effect in a request rule.

Returns a hash containing the names of all the cookies being set in this response, mapped to their values.

This function should be called in a response rule; it has no effect in a request rule.

Returns the value of a named HTTP header in the HTTP response, or the empty string if the header does not exist or has an empty value. The header lookup is case-insensitive.

This function has been deprecated. Use instead http.listResponseHeaderNames().

Returns a list of all the headers that are present in the response.

The headers are returned as a single string, separated by spaces.

Returns a hash containing all the header names in the response mapped to their values.

Returns the version of the HTTP protocol being used. It returns the version string in the first line of the HTTP response, such as 'HTTP/1.1'. It will return the empty string in the case of HTTP/0.9 response.

Returns the Scheme portion of the HTTP request URL. If no scheme was included in the request, this function will return the empty string. For HTTP/2 requests, the scheme is received from the client as the ":scheme" pseudo-header. For HTTP/1.x requests, the scheme is normally omitted unless the traffic manager is being used as an explicit HTTP proxy.

Returns the version string from the HTTP request being sent to the back-end server. For HTTP/0.9 requests, the returned value will be an empty string as there is no version specifier in HTTP/0.9. The returned value will not necessarily match the HTTP version in use by the client as the traffic manager might convert the request before processing it. To obtain the HTTP version in use by the client connection, use http.getClientVersion().

Reports if a named header exists or not. It is similar to http.getHeader(), but makes it possible to distinguish between a header not being present and a header having no value.

The lookup is case-insensitive.

It returns 1 if the header exists, and 0 if it does not.

Returns an array containing the names of all the form parameters present in the URL query string and, if the request is a POST, in the POST body data. If the same parameter appears multiple times in the request, it will only appear once in the list returned by this function.

Returns a list of all the headers that are present in the request.

The headers are returned as an array.

Returns a list of all the headers that are present in the response.

The headers are returned as an array.

Flattens a decoded URL path, converting '//' to '/', '/./' to '/', and flattening '/a/../' to '/'. It returns the flattened path string.

If the file system path is invalid, this function returns the empty string. Invalid paths include those that contain disallowed characters like '\0', invalid hex-escapes, or that use '../' sequences to reference a location outside the local root.

This function should be used on the retrieved URL before attempting path matching for access control. Remember to pass in a %-decoded URL path, to prevent disguised paths and control codes from being 'hidden' in the path.

Sends back an HTTP 302 temporary redirect response, which will instruct a web browser to fetch the specified URL.

The URL specified will be used as the value of the 'Location' header in the response sent to the client. As described in RFC 7231, section 7.1.2, the value of the Location header must be an ASCII-encoded URI-reference, with any illegal characters properly percent-encoded.

Care must be taken when constructing the URL for this function from an untrusted source. As a security measure, if any characters of ASCII value 32 and below are found in the supplied URL, http.redirect will percent-encode them, however this action will not mitigate all potential security problems.

This function, excepting the additional percent-encoding step, is the equivalent of http.sendResponse( "302 Moved Temporarily", "text/html", "", "Location: " . $url );

Cannot be used in completion rules.

Removes the named cookie from the incoming HTTP request.

http.removeCookie is a helper method that makes it easier to parse the HTTP Cookie header and remove a particular cookie, rather than using http.getHeader() and http.setHeader() directly.

Removes a named header if it exists in the request.

Removes a cookie from the HTTP response.

This function should be called in a response rule; it has no effect in a request rule.

Removes the named HTTP header from the HTTP response. The header lookup is case-insensitive.

Reports if a named header exists in the HTTP response. It is similar to http.getResponseHeader(), but makes it possible to distinguish between a header not being present and a header having no value.

Header lookups are case-insensitive.

It returns 1 if the header exists, and 0 if it does not.

Limits the allowed HTTP request headers to a known set. The allowed headers can either be passed in as a list or space separated in a single argument.

Care should be taken when using this function to ensure that the headers that are required for connection handling are let through. At the very least, the following should be allowed: Connection, Content-Length, Transfer-Encoding, Content-Type, Host For a complete list of HTTP headers, refer to RFC2616. Protocols that extend HTTP, such as WebDAV, use other headers.

Limits the allowed HTTP response headers to a known set. The allowed headers can either be passed in as a list or space separated in a single argument.

Care should be taken when using this function to ensure that the headers that are required for connection handling are let through. At the very least, the following should be allowed: Connection, Content-Length, Transfer-Encoding, Location For a complete list of HTTP headers, refer to RFC2616. Protocols that extend HTTP, such as WebDAV, use other headers.

Hands back an HTTP response to the client instead of balancing the request via a pool onto a node. It generates a correct HTTP response from the response code, content type, body data and headers supplied. Multiple headers should be separated with \r\n (note, however, that your traffic manager may override some of these headers, e.g. the 'Connection' header).

For more sophisticated behaviour (for example, compressing responses using http.compress.enable) the http.stream.* methods should be used to respond to a client.

Cannot be used in completion rules.

Sets the request body for this HTTP request to the supplied string, replacing any request body already present.

This also updates the 'Content-Length' header in the request to the length of the new body data.

Cannot be used in completion rules.

Sets the value of the named cookie in the incoming HTTP request.

http.setCookie is a helper method that makes it easier to parse the HTTP Cookie header and set the value of a particular cookie, rather than using http.getHeader() and http.setHeader() directly.

An HTTP 'Cookie' header can have multiple values, such as

Cookie: user-id=Joe; user-type=gold

Replaces the path portion of the request URL with the supplied value. If the replacement value contains a '?', this function will also replace the query string; otherwise, any query string is preserved. Characters whose ASCII value is less than or equal to 32 and '%' will be %-encoded in the replacement value.

Sets the value of the named HTTP header.

A case-insensitive lookup is first performed in order to identify any existing headers, replacing the value where a match is found.

Note that the "Connection" header is manipulated by your traffic manager and that changing its value in TrafficScript may not give the expected results.

If an invalid header name is specified, the function will print a warning and return without modifying the HTTP request.

Marks a request as resendable or non-resendable.

An idempotent request has no detrimental side effects, so it can safely be submitted multiple times. A simple page retrieval is generally idempotent. A non-idempotent request has a side effect - for example, it may update a database, or initiate a purchase. The HTTP/1.1 specification regards all GET, HEAD, PUT, DELETE, OPTIONS and TRACE requests as idempotent.

Your traffic manager tags these requests as 'resendable'; if the request is submitted to a back-end node and a correct response is not received, your traffic manager will resubmit the request to another back-end node. All other requests, such as POST requests are not resent if a back-end node fails to generate a correct response.

http.setIdempotent() can override this behaviour. If 'resend' has a non-zero value, this indicates that if the request is submitted to a back-end node and a correct response is not received, your traffic manager should resubmit the request to another back-end node.

If 'resend' is zero, this indicates that the request should only be attempted against one back-end node.

Note that a request cannot be resent if it has begun streaming data from the client to the node before it detects the failure. To avoid this, you can read the entire request within the TrafficScript rule, so that it is buffered in its entirety internally in the TrafficManager.

Cannot be used in completion rules.

Sets the HTTP method, changing the original request.

Replaces the path portion of the request URL with the supplied value. If the replacement value contains a '?', this function will also replace the query string; otherwise, any query string is preserved. This function will %-encode any character excluding following set as defined in RFC3986 - Unreserved: A-Z, a-z, 0-9, ., _, - - Reserved: !, *, (, ), ;, :, @, &, =, +,' $, ',', ?, /, #, [, ] - '%'

Replaces the query-string portion of the request URL with the supplied replacement. Any control characters in the replacement are %-encoded.

Replaces the path portion of the request URL with the supplied value. If the replacement value contains a '?', this function will also replace the query string; otherwise, any query string is preserved. URL will not be %-encoded.

Replaces the query-string portion of the request URL with the supplied replacement. Unlike http.setQueryString, control characters are not encoded.

Sets the response body for this HTTP response to the supplied string, replacing any response body already present.

This also updates the 'Content-Length' header in the response to the length of the new body data. In addition the 'Content-Encoding' header is removed as we only ever set body data which is not encoded or compressed. If the server is still sending the original response body when this function is called, the connection to the server will be harmlessly dropped.

The optional 'transfer-encoding' parameter indicates the encoding of the body data (for example, 'chunked').

Cannot be used in completion rules.

Sets the status code and message in the first line of the HTTP response.

Sets a cookie in the HTTP response. If the named cookie already exists, this function replaces its value.

The options are a semi-colon separated list of cookie options, such as "domain", "path", "expires" and "secure".

If the named cookie exists and no 'options' are provided, the current options for the named cookie are preserved.

This function may be called from a request rule or a response rule.

Sets a HTTP header in the HTTP response that will be sent back to the client. If the header already exists in the response, then it will be replaced with this new value. The header lookup is case-insensitive.

Note that this function should not be used with the Connection header, i.e. setResponseHeader("Connection", value) since it may not give the expected results.

If an invalid header name is specified, the function will print a warning and return without modifying the HTTP request.

Do not use Web Accelerator to optimize the result of this request. Note that http.aptimizer.bypass() should not be used to turn off content optimization for requests that have been previously optimized as this might result in some requests not being served. Instead, create a new Web Accelerator profile with the mode set to 'Idle' and assign this profile to the request using http.aptimizer.use().

Cannot be used in completion rules.

Use the specified Web Accelerator scope and profile to optimize web content served to the client that sent this request. If the named Web Accelerator scope or profile does not exist then a warning message will be logged and the traffic manager will choose a scope matching the request based on the Web Accelerator settings configured for the virtual server, and use the associated profile. If no scope matches the request then no optimization will occur. If the virtual server does not have Web Accelerator enabled, then a warning message will be logged and no optimization will occur.

Cannot be used in completion rules.

If the HTTP request has been authenticated via Authentication configured on the relevant Virtual Server, the authenticated user name can be fetched with this function. Basic-Auth or non-authenticated requests will return the empty string.

Prevents this response from being cached. In a request rule, this additionally prevents a cache lookup for this request.

Cannot be used in completion rules.

Performs the opposite function to http.cache.disable(), and re-enables the default caching behaviour when the dynamic caching option in the virtual server is enabled.

Cannot be used in completion rules.

Returns 1 if the current request can (currently) be responded to from the cache, otherwise 0.

Note that even if the request is in the cache at the time of this call, it may be removed from the cache by the time that TrafficScript processing has finished and the traffic manager can send it. If a cached response must be guaranteed, http.cache.respondIfCached() should be used.

A pool name can be provided as optional argument in order to make the lookup use the specified pool. Without this argument, the lookup will use the pool previously selected with pool.select or the virtual server's default pool.

This function always returns 0 if called in a response rule.

Sends a cached response to the client without any further rule processing and without connecting to a back-end server. If no match is found in the cache or if the request does not allow cached responses, rule processing continues normally. If the response can be served from the cache, no statements after this function call will be processed and the client will get the cached page.

A pool name can be provided as optional argument in order to make the lookup use the specified pool. Without this argument, the lookup will use the pool previously selected with pool.select or the virtual server's default pool.

This function does nothing if called in a response rule.

Cannot be used in completion rules.

Allows multiple variants of the same URL to be considered distinct objects, even if the standard 'Vary' RFC semantics would consider the pages identical. Cached objects will be stored with this key, and subsequent requests for the same URL will only match if the same key is provided. An example use is to provided different cached content based on a portion of the User-Agent field of the request.

Note that successive uses of this function will overwrite the previous use rather than append the new key to it.

Note that keys longer than 31 bytes will be shortened using a non-cryptographic digest function. Passing the output of a cryptographic hash function applied to such a key may give better results, for example string.drop( string.hashSHA256( $key ), 1 ) returns the first 31 bytes of a SHA-2 hash of the $key.

Cannot be used in completion rules.

Stops this HTTP response from being compressed. This function overrides the Virtual Server Content Compression settings, so this is useful for stopping particular MIME types for certain browsers from being compressed.

Cannot be used in completion rules.

Allows this individual HTTP response to be compressed. If this function is called for an HTTP response, then the Virtual Server settings for Content Compression are ignored, and the response will be compressed, assuming that the client supports compression. This function return 0 if it successfully enables compression

Cannot be used in completion rules.

When a request is received via an HTTP/2 stream, calling this function will result in the traffic manager sending an ORIGIN (RFC 8336) frame to the client on the control stream. The ORIGIN frame will have the supplied URLs in the array provided as its entries.

The ORIGIN frame informs the browser that the specified URL(s) are provided authoritatively by this same virtual server, and requests for these websites can be coalesced into the same HTTP/2 connection. The URLs must start with http:// or https://, contain an optional port number, and must not provide a trailing path.

The http.connection.sendOrigin() function has no effect if the request is not a valid HTTP/2 request. If the function is called for additional requests sent over the same HTTP/2 connection, subsequent ORIGIN frames will be sent only if the URLs supplied differ from the previous invocation of http.connection.sendOrigin() for that connection. Browser behavior in response to receiving an ORIGIN frame may vary.

Cannot be used in completion rules.

Return the principal name to be used for this client in Kerberos Protocol Transition. If http.kerberos.setClientPrincipalName was called, returns the value set by it, otherwise if a principal name can be deduced from any client certificate, returns that. The empty string will be returned in the case of no principal name, or failure.

Attempts to get a Kerberos ticket delegated to this client using Protocol Transition, encoded for use in an Authorization header. Uses the value returned by http.kerberos.getClientPrincipalName to identify the client principal to be delegated to. If a pool has been set (with pool.use, or in a response rule), uses the Kerberos Principal Configuration set for that pool (if any), otherwise uses the one set for the virtual server.

Cannot be used in completion rules.

Returns the name of the Kerberos principal catalog item that is currently configured for use by the traffic manager when performing Kerberos Protocol Transition. If http.kerberos.setPrincipal was called, returns the value set by it, otherwise the value from the configuration will be returned if present. The empty string will be returned in the case of no configured principal name, or failure.

Return the principal name to be used for the target service in Kerberos Protocol Transition. If http.kerberos.setTargetPrincipalName was called, returns the value set by it, otherwise the value from the configuration will be returned if present. The empty string will be returned in the case of no configured principal name, or failure.

Returns true if Kerberos protocol transition is currently enabled on the connection, otherwise false.

Sets the principal name to be used for this client in Kerberos Protocol Transition.

Cannot be used in completion rules.

Explicitly specify whether Kerberos protocol transition should be used on the connection. The value set will override any configuration on the virtual server.

Cannot be used in completion rules.

Sets the name of the Kerberos principal catalog item that is to be used for performing Kerberos Protocol Transition.

Cannot be used in completion rules.

Sets the principal name to be used for the target service for Kerberos Protocol Transition.

Cannot be used in completion rules.

Issues an HTTP DELETE request for a remote web page. $1 is set to the HTTP response code (e.g. 204 for OK), or is 0 if there was an error. $2 is set to the Content-Type of the response (or an error message if there was an error). $3 is set to the content-headers of the response, in the format: [<header-line>\r\n]*. $4 is set to the first line of the HTTP response. The entire original response may be reconstructed as $4."\r\n".$3."\r\n".$body, where $body is the result of http.request.get.

HTTPS pages can be requested by using the https:// prefix for the url.

A timeout parameter can be given (in seconds). If the request does not complete in this time, then an error will be given instead.

Requests made with http.request.delete() will use keepalive connections to the destination server. Provided the request was completed successfully, these keepalive connections will be re-used by any invocation of http.request.delete(), http.request.head() or http.request.get() to the same destination host:port, from any rule, in any virtual server. If the request is to a node in a pool, the connection will be shared with other requests your traffic manager makes to the same node. If the request made with http.request.delete() was unsuccessful, your traffic manager closes the connection.

Cannot be used in completion rules.

Issues an HTTP request for a remote web page and returns the body of the page requested. $1 is set to the HTTP response code (e.g. 200 for OK), or is 0 if there was an error. $2 is set to the Content-Type of the response (or an error message if there was an error). $3 is set to the content-headers of the response, in the format: [<header-line>\r\n]*. $4 is set to the first line of the HTTP response. The entire original response may be reconstructed as $4."\r\n".$3."\r\n".$body, where $body is the result of http.request.get.

HTTPS pages can be requested by using the https:// prefix for the url.

A timeout parameter can be given (in seconds). If the request does not complete in this time, then an error will be given instead.

Requests made with http.request.get() will use keepalive connections to the destination server. Provided the request was completed successfully, these keepalive connections will be re-used by any invocation of http.request.get() or http.request.head() to the same destination host:port, from any rule, in any virtual server. If the request is to a node in a pool, the connection will be shared with other requests your traffic manager makes to the same node. If the request made with http.request.get() was unsuccessful, your traffic manager closes the connection.

Cannot be used in completion rules.

Issues an HTTP HEAD request for a remote web page. $1 is set to the HTTP response code (e.g. 200 for OK), or is 0 if there was an error. $2 is set to the Content-Type of the response (or an error message if there was an error). $3 is set to the content-headers of the response, in the format: [<header-line>\r\n]*. $4 is set to the first line of the HTTP response. The entire original response may be reconstructed as $4."\r\n".$3."\r\n".$body, where $body is the result of http.request.get.

HTTPS pages can be requested by using the https:// prefix for the url.

A timeout parameter can be given (in seconds). If the request does not complete in this time, then an error will be given instead.

Requests made with http.request.head() will use keepalive connections to the destination server. Provided the request was completed successfully, these keepalive connections will be re-used by any invocation of http.request.head() or http.request.get() to the same destination host:port, from any rule, in any virtual server. If the request is to a node in a pool, the connection will be shared with other requests your traffic manager makes to the same node. If the request made with http.request.head() was unsuccessful, your traffic manager closes the connection.

Cannot be used in completion rules.

Issues an HTTP POST request for a remote web page, and returns the body of the page requested. $1 is set to the HTTP response code (e.g. 200 for OK), or is 0 if there was an error. $2 is set to the Content-Type of the response (or an error message if there was an error). $3 is set to the content-headers of the response, in the format: [<header-line>\r\n]*. $4 is set to the first line of the HTTP response. The entire original response may be reconstructed as $4."\r\n".$3."\r\n".$body, where $body is the result of http.request.post.

HTTPS pages can be requested by using the https:// prefix for the url.

A timeout parameter can be given (in seconds). If the request does not complete in this time, then an error will be given instead.

Requests made with http.request.post() will always create a new connection to the destination server and will not use an existing connection. After a request made with http.request.post() has finished successfully, its connection can be re-used by any invocation of http.request.get() or http.request.head() to the same destination host:port, from any rule, in any virtual server. If the request was to a node in a pool, the connection will also be shared with other requests your traffic manager makes to the same node. If the request made with http.request.post() was unsuccessful, your traffic manager closes the connection.

Cannot be used in completion rules.

Issues an HTTP PUT request for a remote web page, and returns the body of the page requested. $1 is set to the HTTP response code (e.g. 200 for OK), or is 0 if there was an error. $2 is set to the Content-Type of the response (or an error message if there was an error). $3 is set to the content-headers of the response, in the format: [<header-line>\r\n]*. $4 is set to the first line of the HTTP response. The entire original response may be reconstructed as $4."\r\n".$3."\r\n".$body, where $body is the result of http.request.put.

HTTPS pages can be requested by using the https:// prefix for the url.

A timeout parameter can be given (in seconds). If the request does not complete in this time, then an error will be given instead.

Requests made with http.request.put() will always create a new connection to the destination server and will not use an existing connection. After a request made with http.request.put() has finished successfully, its connection can be re-used by any invocation of http.request.get() or http.request.head() to the same destination host:port, from any rule, in any virtual server. If the request was to a node in a pool, the connection will also be shared with other requests your traffic manager makes to the same node. If the request made with http.request.put() was unsuccessful, your traffic manager closes the connection.

Cannot be used in completion rules.

Issues an HTTPS request for a remote web page and returns the body of the page requested. Its behavior is identical to that of http.request.get when used with an HTTPS URL except for the following differences:

Cannot be used in completion rules.

Stops streaming any data from the current rule and lets your traffic manager send remaining data from backend. The 'data' parameter can be used to send the last block to be streamed. Rule processing will finish and no further statements in this or subsequent rules will be executed. Unlike http.stream.finishResponse(), any data coming from the backend server will continue to be sent from the backend to the client normally.

Note that this function will behave exactly like http.stream.finishResponse() if run from a request rule.

Cannot be used in completion rules.

Indicates that 'data' is the last block to be streamed for the current transaction. Rule processing will stop after http.stream.finishResponse() has been called, i.e. the remaining statements of the present rule will not be evaluated and no subsequent rules will be run.

Cannot be used in completion rules.

Reads (and consumes) data from the server, so that TrafficScript can manipulate the data and send a modified version to the client.

Reads the number of bytes specified by 'count' from the body of the HTTP response supplied by the server. Data from the response is only returned up to and including the "last" occurrence of 'delimiter' if a non-empty delimiter has been specified. Unlike http.getResponseBody(), it also removes the data returned from the server's response. When the end of the response from the server has been reached, an empty string is returned.

If the delimiter partially matches at the end of the specified number of bytes, the data returned will include the full delimiter (thus returning slightly more data than specified). If the delimiter is not found in the specified number of bytes, then the specified number of bytes of data will be returned.

Cannot be used in completion rules.

Similar to http.stream.readBulkResponse(), but only returns response body data up to and including the "first" occurrence of delimiter. The two functions behave identically if no delimiter is provided.

Cannot be used in completion rules.

Sets up an HTTP response from which data can be streamed later by calling http.stream.writeResponse(). http.stream.startResponse() can only be called once per HTTP transaction. Only 'resp_code' and 'content_type' are mandatory arguments. However, it is recommended to specify the 'content_length' if possible. If it is provided and a valid integer, your traffic manager will not stream more than that number of bytes. A set of headers (separated by "\r\n") can be provided in the optional fourth argument. In a response rule, if no fourth argument is given, the response headers from the back-end will be sent on to the client (note, however, that your traffic manager may override some of these headers, e.g. the 'Connection' header)

Cannot be used in completion rules.

Sends the data in the 'data' argument to the client. http.stream.writeResponse() can be called multiple times but http.stream.startResponse() must have been called beforehand.

Cannot be used in completion rules.

Runs a named Java Extension. The Java Extension class name must be given, and extra options can also be supplied to the Extensions. (These are supplied as the 'args' attribute in the Java Extension API). To use java.run(), first enable Java support through the Traffic Manager Admin UI or product APIs.

Can only be used with TCP-based protocols, Cannot be used in completion rules.

Generate the signature or digest for the input token( encoded jose header and claims ) using provided key and return the hash of "error" and "description" if generation fails or "signature" if generation is successfull.

JWT tokens are used to represent claims in cryptographically safe manner.

Cannot be used in completion rules.

Parse the header of a JWT token and returns a hash of "error" and "description" if parsing fails else hash of key/value pairs present in header.

JWT tokens are used to represent claims in cryptographically safe manner.

Cannot be used in completion rules.

Validates the JWT token against the provided key with expected algorithms and return the hash of "error" and "description" if validation fails or "claim" if validation is successful.

JWT tokens are used to represent claims in cryptographically safe manner.

Cannot be used in completion rules.

Writes an error message to the traffic managers's event log file. This log can be viewed through the UI.

Writes an informational message to the traffic manager's event log file. This log can be viewed through the UI.

Writes a warning message to the traffic manager's event log file. This log can be viewed through the UI.

Resolves a hostname into an IPv4 address, using the DNS name servers configured on the local system. If the lookup fails, an empty string is returned.

Cannot be used in completion rules.

Resolves a hostname into an IPv6 address, using the DNS name servers configured on the local system. If the lookup fails, an empty string is returned.

Cannot be used in completion rules.

Resolves an IP address to a hostname, using the DNS name servers configured on the local system.

Returns a hostname, or the IP address if the address cannot be resolved. An empty string is returned if the parameter is not a valid IP address.

Cannot be used in completion rules.

Returns the number of nodes that are alive in the named pool. This will not include any nodes that have been marked as 'draining'.

Query the pool to determine the status of a node. Will return one of : "NOTINPOOL","NOSUCHPOOL","NOSUCHHOST","DEAD" "ACTIVE","DISABLED","DRAINING"

Note: "DRAINING" is only returned for nodes present in the pool's configuration and in the 'draining' state. Nodes deleted from a pool with the 'drain to delete' behavior enabled via the node_delete_behavior configuration key will show as "NOTINPOOL".

Cannot be used in completion rules.

Returns the number of nodes that are have been marked as disabled in the named pool.

Returns the number of nodes that are draining in the named pool.

Returns the number of nodes that have failed in the named pool.

Lists the IP addresses of the nodes that are alive in the named pool. This will not include any nodes that have been marked as 'draining'.

Lists the IP addresses of all the nodes including disabled nodes.

Lists the IP addresses of the nodes that are disabled in the named pool.

Lists the IP addresses of the nodes that are draining in the named pool.

Lists the IP addresses of the nodes that are marked as failed in the named pool.

Selects a pool to load-balance this connection with. By default, the pool name should be a literal string (i.e. not dynamically generated and not containing any variables), however, if you enable the "trafficscript!variable_pool_use" global setting variables can be used too. Please refer to the Troubleshooting section of the vTM TrafficScript Overview and Reference Manual for more information about this setting. Unlike pool.use(), your traffic manager will continue to process further request rules after this function.

If the pool named does not exist, your traffic manager will log a warning message.

Optionally, a specific machine can be specified that will be used to forward the request on to. This machine does not have to be in the pool selected, or in fact in any pool. In this mode, the selected pool is used only for its configuration settings (e.g. timeout values, SSL encryption options, etc.) The request will bypass any queueing based on connection or transaction limits defined for the pool.

If the machine is specified as an empty string, a node will be chosen from the pool normally. However the connection will be made to the specified port instead of the port specified in the pool configuration.

Cannot be used in completion rules.

Selects a pool to load-balance this connection with, and stops processing any more rules. It must only be used in request rules.

By default the pool name should be a literal string, however, if you enable the "trafficscript!variable_pool_use" global setting, variables can be used too. Please refer to the Troubleshooting section of the vTM TrafficScript Overview and Reference Manual for more information about this setting.

If the pool named does not exist, your traffic manager will log a warning message and use the default pool configured for the virtual server.

Optionally, a specific machine can be specified that will be used to forward the request on to. This machine does not have to be in the pool selected, or in fact in any pool. In this mode, the selected pool is used only for its configuration settings (e.g. timeout values, SSL encryption options, etc.) The request will bypass any queueing based on connection or transaction limits defined for the pool.

If the machine is specified as an empty string, a node will be chosen from the pool normally. However the connection will be made to the specified port instead of the port specified in the pool configuration.

Cannot be used in completion rules.

Obtains the RADIUS calling station identifier (attribute 31) as specified in RFC 2865.

If successful, returns the calling station identifier from a RADIUS Access-Request packet. A return value of -1 indicates a failure; in this case an error string will be stored in '$1'. This function should be used in a request rule so that the Access-Request packets are visible to it.

Cannot be used in completion rules.

Returns the number of connections that are currently waiting to be released by the supplied rate class.

Cannot be used in completion rules.

Immediately queues a connection using the named rate class.

The connection and the current TrafficScript rule is stalled until the rate class releases it, according to the rate limits defined in the class. When the connection is released, the rate.use() function returns and the TrafficScript rule continues to execute.

If rate.use() is called with the optional 'context' value, it uses a new rate class which inherits all of the rate settings from the named rate class. All connections called with the same 'context' value use the same new rate class. This allows you to shape connections based on arbitary data, such as a user name or source IP address, shaping connections from different users or source IPs independently.

If the connection has passed through the class successfully then the value 1 is returned. If the connection times out while it is queued, then the TrafficScript rule is abandoned. If the connection could not be queued because an invalid rate class name was provided, rate.use() returns 0.

Cannot be used in completion rules.

Checks if this connection will exceed the rate limits of the named rate class. If connection is within rate limits, a value of 1 is returned and the connection is added to rate usage data. If usage has exceeded rate limits, a value of 0 is returned. If the rate class does not exist, a value of -1 will be returned.

Optionally a context value can be used to check rate limits based on a context, for example, rate limits for a specific client IP address. See rate.use for more details on context.

Unlike rate.use(), this will not queue connections if the rate limit is exceeded.

Note that calling rate.use() after rate.use.noQueue() will mean that the connection is counted twice, halving the allowed rate.

Cannot be used in completion rules.

Specifies that this connection should not be saved in the Recent Connections buffer upon completion. This function can be used when the virtual server has recent_conns!save_all set to Yes to filter out unwanted connections from the Recent Connections page.

Note that recent_conns!enabled must be set to Yes on the virtual server for any connections to be saved.

Mark this connection for inclusion in the Recent Connections buffer. Details about this connection can then be viewed on the Activity > Connections page.

Note that recent_conns!enabled must be set to Yes on the virtual server for any connections to be saved.

Returns true if the connection will be added to the Recent Connections buffer, or false otherwise.