Global Parameters and Variables in Junos OS Automation Scripts
Junos OS automatically provides input to automation scripts when the scripts are executed. The script can reference this input, which includes device-specific information about the script execution environment such as the device hostname, the script type, and the user executing the script. This information is useful for creating scripts that respond to a variety of complex scenarios.
SLAX and XSLT scripts that import the junos.xsl file can reference
this information using the $junos-context global variable, which is a
node-set. The junos.xsl import file also declares several
predefined global parameters that enable the scripts to more easily reference a subset
of this information. Python scripts can reference this information through the
junos.Junos_Context dictionary, which you must import into the
script.
To use the pre-defined parameters or global variable in SLAX and XSLT scripts, you must import the junos.xsl file as shown in the following examples:
XSLT Syntax
<?xml version="1.0"?> <xsl:stylesheet version="1.0"> <xsl:import href="../import/junos.xsl"/> ... </xsl: stylesheet>
SLAX Syntax
version 1.2; import "../import/junos.xsl";
Python
To reference the information in Python scripts, import the Junos_Context
dictionary.
from junos import Junos_Context
This topic describes the script input in detail.
Global Parameters Available in SLAX and XSLT Scripts
Several predefined global parameters are available for use in SLAX and XSLT automation scripts that import the junos.xsl file. The parameters provide information about the Junos OS environment. Table 1 describes the built-in arguments.
|
Name |
Description |
Example |
|---|---|---|
|
|
Hostname of the local device |
Tokyo |
|
|
Local time at which the script executes |
Fri Dec 10 11:42:21 2024 |
|
|
Local time, in ISO format, at which the script executes |
2024-12-10 11:42:21 PST |
|
|
Model of the local device |
mx960 |
|
|
Filename of the executing script |
test.slax |
|
|
Local name of the user executing the script |
root |
The junos.xsl file declares the predefined global parameters. Thus, you do not need to declare these parameters in your script in order to use them. Access the value of the global parameters in a script by prefixing the parameter name with the dollar sign ($), as shown in the following examples:
SLAX syntax:
if ($user != "root") {
var $script-message = $user _ " does not have permission to execute " _ $script;
expr jcs:output($script-message);
}XSLT syntax:
<xsl:if test="$user != 'root'">
<xsl:variable name="script-message"
select="concat($user, ' does not have permission to execute ', $script)"/>
<xsl:value-of select="jcs:output($script-message)"/>
</xsl:if>Global Variable Available in Automation Scripts
Commit, event, and op scripts can access specific environment information upon
execution. To access this information, Python scripts must import and reference the
junos.Junos_Context dictionary. SLAX and XSLT scripts that
import the junos.xsl file can reference the
$junos-context global variable. $junos-context
and Junos_Context contain identical information but in a format
that is suitable for the respective script language.
The $junos-context variable is a node-set that contains the
<junos-context> node and the following hierarchy, which
is common to and embedded in the source tree of all scripts:
<junos-context>
<chassis></chassis>
<hostname></hostname>
<localtime></localtime>
<localtime-iso></localtime-iso>
<pid></pid>
<product></product>
<re-master/>
<routing-engine-name></routing-engine-name>
<sw-upgrade-in-progress></sw-upgrade-in-progress>
<script-type></script-type>
<tty></tty>
<user-context>
<class-name></class-name>
<login-name></login-name>
<uid></uid>
<user></user>
</user-context>
</junos-context>Additionally, script-specific information is available depending on the type of
script executed. The source tree provided to an op script includes the
<op-context> element.
<junos-context>
<op-context>
<via-url/>
</op-context>
</junos-context>
The source tree provided to a commit script includes the
<commit-context> element.
<junos-context>
<commit-context>
<commit-comment>"This is a test commit"</commit-comment>
<commit-boot/>
<commit-check/>
<commit-sync/>
<commit-confirm/>
<database-path/>
</commit-context>
</junos-context>Table 2 identifies each node of the $junos-context variable node-set.
For each node, the table also provides a brief description and gives examples for
those elements that have values.
|
Parent Node |
Node |
Description |
Example Content |
|---|---|---|---|
|
|
|
Specifies whether the script is executed on the Root System Domain (RSD) or a Protected System Domain (PSD) |
|
|
|
Hostname of the local device |
Tokyo |
|
|
|
Local time when the script executes |
Fri Dec 10 11:42:21 2024 |
|
|
|
Local time, in ISO format, when the script executes |
2024-12-10 11:42:21 PST |
|
|
|
cscript process ID |
5257 |
|
|
|
Model of the local device |
mx960 |
|
|
|
Empty element included if the script executes on the primary Routing Engine |
– |
|
|
|
Routing Engine on which the script executes |
re0 |
|
|
|
Type of script being executed |
op |
|
|
|
Element that enables a commit script to check if the commit occurs during the first reboot after a software install. The tag value is |
yes |
|
|
|
TTY of the user’s session |
/dev/ttyp1 |
|
|
|
|
Login class of the user executing the script |
superuser |
|
|
Login name of the user executing the script. For AAA access, this value is the RADIUS/TACACS username. |
admin |
|
|
|
User ID of the user executing the script as defined in the device configuration |
2999 |
|
|
|
Local name of the user executing the script. Junos OS uses the
local name for authentication. It might differ from the
|
root |
|
|
(op scripts only) |
|
Empty element included if you use the |
– |
|
(commit scripts only) |
|
Empty element included when the commit occurs at boot time |
– |
|
|
Empty element included when the script executes during a
|
– |
|
|
|
User comment regarding the commit |
Commit to fix forwarding issue |
|
|
|
Empty element included when the script executes during a
|
– |
|
|
|
Empty element included when the script executes during a
|
– |
|
|
|
Element specifying the location of the session’s pre-inheritance
candidate configuration. For normal configuration sessions, the
value of the element is the location of the normal candidate
database. For private configuration sessions, the value of the
element is the location of the private candidate database. When
the |
– |
The $junos-context variable is a node-set. Therefore, you can access
the child elements throughout a script by including the proper XPath
expression. The following SLAX commit script writes a message to the system log file
if the commit occurs during the initial boot-up. The script assigns a
facility value of daemon and a severity value of
info to the message. For more information, see syslog().
version 1.2;
ns junos = "http://xml.juniper.net/junos/*/junos";
ns xnm = "http://xml.juniper.net/xnm/1.1/xnm";
ns jcs = "http://xml.juniper.net/junos/commit-scripts/1.0";
import "../import/junos.xsl";
match configuration {
if ($junos-context/commit-context/commit-boot) {
expr jcs:syslog("daemon.info", "This is boot-time commit");
} else {
/* Do this ... */
}
}
Python scripts must import the Junos_Context dictionary from the
junos module to access the environment-specific information
provided to scripts. The keys in the Junos_Context dictionary are
identical to the names of the $junos-context nodes outlined in
Table 2. Nodes with child elements that are nested under the
junos-context node such as user-context,
op-context, and commit-context map to items in
Junos_Context, where the key is the node name and the value is
a dictionary of the node’s child elements. For example:
'user-context': {'login-name': 'bsmith', 'user': 'bsmith', 'class-name': 'j-superuser', 'uid': '9999'}The following example output displays the Junos_Context dictionary
for a locally executed op script. Note that the op script input contains the
op-context key, which in this scenario is empty.
{'product': 'mx960', 'user-context': {'login-name': 'bsmith', 'user': 'bsmith', 'class-name': 'j-superuser', 'uid': '9999'}, 'routing-engine-name': 're0', 'script-type': 'op', 're-master': None, 'hostname': 'R1', 'pid': '7136', 'tty': '/dev/ttyp1', 'chassis': 'others', 'op-context': ' ', 'localtime': 'Thu Jan 22 11:45:47 2025', 'localtime-iso': '2025-01-22 11:45:47 PST'}The following example output displays the Junos_Context dictionary
for a commit script that was executed during a commit check
operation. Note that the commit script input contains the
commit-context key.
{'product': 'mx960', 'user-context': {'login-name': 'bsmith', 'user': 'bsmith', 'class-name': 'j-superuser', 'uid': '9999'}, 'routing-engine-name': 're0', 'script-type': 'commit', 're-master': None, 'hostname': 'R1', 'pid': '11201', 'tty': '/dev/ttyp1', 'commit-context': {'database-path': '/var/run/db/juniper.db', 'commit-check': None}, 'chassis': 'others', 'localtime': 'Thu Jan 22 16:23:55 2025', 'localtime-iso': '2025-01-22 16:23:55 PST'}To access individual values in the dictionary, specify the key name. For example:
Junos_Context['hostname'] Junos_Context['user-context']['class-name']