A Run-Time Environment (RTE) is a persistant scripting environment with similar objectives to CGIplus ... reducing script response time, increasing server throughput and reducing system impact. In fact the RTE environment is implemented using CGIplus! There is very little difference in the behaviour of CGIplus scripts and RTEs. Both are activated by the server, process multiple requests (reading the request CGI environment from a data stream supplied by the server), persist between requests in a quiescent state, and may be removed by the server if idle for a specified period or when it wishes to use the process for some other purpose. Like CGIplus an RTE must be purpose-written for the environment! What is the difference then?
With CGIplus the script itself persists between uses, retaining all of its state. With an RTE the script does not persist or retain state, only the RTE itself.
A RTE is intended as an environment in which a script source is interpreted or otherwise processed, that is for scripting engines, although it is not limited to that. The essential difference between an RTE and a CGIplus script is this script source. In CGIplus the SCRIPT_NAME and SCRIPT_FILENAME CGI variables reflect the script itself, and remain constant for each activation of the script, with PATH_INFO and PATH_TRANSLATED providing the additional "location" information for the script processing. With an RTE the SCRIPT_NAME and SCRIPT_FILENAME can vary with each activation. This allows the RTE to process multiple, successive different (or the same) scripts, each with its own PATH_INFO and PATH_TRANSLATED. Hence, it is not unreasonable to consider the two environments to be the same, with a slight difference in the mapping of resources passed to them.
This might be best illustrated with examples.
Consider the mapping rule
exec+ /cgiplus-bin/* /cgi-bin/*applied to the following CGIplus request
If the script was an executable it would be activated as
CGI-BIN:XYZ.EXEwith script CGI information
/cgiplus-bin/xyz CGI-BIN:XYZ.EXEand the request path information and query string supplied as
/the/path/information THE:[PATH]INFORMATION and=a&query=string
By contrast with a request to activate an RTE the following mapping rule
exec+ /xyz-bin/* (CGI-BIN:XYZ.EXE)/wasd_root/src/xyz/*(note the RTE executable specified inside parentheses) and request
/xyz-bin/an_example/the/path/information?and=a&query=stringwould activate the scripting environment (perhaps interpreter)
CGI-BIN:XYZ.EXEsupplying it with per-request script name and file information
/xyz-bin/an_example.xyz WASD_ROOT:[SRC.XYZ]AN_EXAMPLE.XYZand path and query string information
/the/path/information THE:[PATH]INFORMATION and=a&query=string
As can be seen the script information is constant for each request to a CGIplus script, while with RTE the script information could vary with each request (although of course it would be the same if the same script is requested). In the case of CGIplus the process what? request information is provided only by path information, however with RTE both script and path information are used.
The RTE interface is still CGI, with all the usual environment variables and input/output streams available, just in a CGIplus environment! Hence when coding a Run-Time Environment the same considerations involved in CGIplus programming apply (3 - CGIplus).
In particular it is important a RTE should explicitly close files, free allocated memory, etc., after processing a request (of course it cannot rely on image run-down to clean-up after itself). It is particularly important that all traces of each script's processing are removed after it concludes. This does not mean for example that databases need to be completely closed, etc., which might defeat the purpose of using a persistant environment, just that great care must be exercised by the programmer to prevent one script interfering with another!
An example RTE, WASD_ROOT:[SRC.CGIPLUS]RTE_EXAMPLE.C provides the basics of the environment.
A source code collection of C language functions useful for processing the more vexing aspects of CGI/CGIplus/RTE programming (1.12 - Scripting Function Library). The example RTE implementation uses this library.
The following configuration information uses the supplied Perl RTE as the example. Note that RTE scripting engines must always be mapped using the EXEC+ rules. The SCRIPT+ rule does not apply.
The following rule in WASD_CONFIG_MAP maps the /pl-bin/ location to where the site wishes to locate its CGI Perl scripts (not necessarily the same as in the example).
exec+ /pl-bin/* (CGI-BIN:PERLRTE.EXE)/wasd_root/src/perl/*
With this rule Perl scripts may be accessed using
This WASD_CONFIG_GLOBAL rule ensures Perl scripts could be activated via the Perl RTE even if the WASD_CONFIG_MAP rule did not exist (1.7 - Script Run-Time).
[DclScriptRunTime] .PL (CGI-BIN:PERLRTE.EXE)
The server makes no check of the RTE executable (or procedure) before attempting to activate it using DCL for processing the script. If it does not exist or is not accessible due to incorrent file protections the DCL of the scripting process will report the problem.
It does by default however, check that the file used as the script source exists as with other scripting environments. If it does not this is reported as a "script not found". For RTEs that wish to report on this themselves, or that possibly construct their own script specification via some internal processing, this server behaviour may be suppressed for the script activation path using the WASD_CONFIG_MAP path SETting "script=nofind" as in the following example.
set /xyz-bin/* script=nofind exec+ /xyz-bin/* (CGI-BIN:XYZ.EXE)/wasd_root/src/xyz/*
CGI environment variables SCRIPT_FILENAME and PATH_TRANSLATED can be provided to any RTE script in Unix file-system syntax should that script require or prefer it using this format. See 1.8 - Unix Syntax.
If the RTE executable requires wrapping in a DCL procedure (perhaps to provide some command-line specific parameter or define a C-RTL logical name) this can be specified in place of an executable. Merely prefix the specification with a "@". The default is to run an executable (this can explicitly be specified using a leading "$") while the leading "@" provides a DCL procedure activation.