- play_arrow Overview
- play_arrow Junos Automation Scripts Overview
- play_arrow Junos XML Management Protocol and Junos XML API Overview
-
- play_arrow Automation Scripting Using XSLT
- play_arrow XSLT Overview
- play_arrow Standard XPath and XSLT Functions Used in Automation Scripts
- play_arrow Standard XSLT Elements and Attributes Used in Automation Scripts
-
- play_arrow Automation Scripting Using SLAX
- play_arrow SLAX Overview
- SLAX Overview
- SLAX Syntax Rules Overview
- SLAX Elements and Element Attributes Overview
- SLAX Elements as Function Arguments
- Understanding SLAX Default Namespaces
- XPath Expressions Overview for SLAX
- SLAX Templates Overview
- SLAX Functions Overview
- SLAX Parameters Overview
- SLAX Variables Overview
- SLAX Statements Overview
- XSLT Elements Without SLAX Equivalents
- SLAX Operators
- play_arrow SLAX Statements
- append
- apply-imports
- apply-templates
- attribute
- attribute-set
- call
- copy-node
- copy-of
- decimal-format
- element
- else
- else if
- expr
- fallback
- for
- for-each
- function
- if
- import
- key
- match
- message
- mode
- mvar
- number
- output-method
- param
- preserve-space
- priority
- processing-instruction
- result
- set
- sort
- strip-space
- template
- terminate
- trace
- uexpr
- use-attribute-sets
- var
- version
- while
- with
- play_arrow The libslax Distribution for Automation Scripting
- libslax Distribution Overview
- libslax Library and Extension Libraries Overview
- Download and Install the libslax Distribution
- libslax Default Extension Libraries: bit, curl, db, os, and xutil
- Understanding the SLAX Processor (slaxproc)
- How to Use the SLAX Processor (slaxproc)
- SLAX Debugger, Profiler, and callflow
-
- play_arrow Automation Scripting Using Python
- play_arrow Python Overview
- Understanding Python Automation Scripts for Junos Devices
- Requirements for Executing Python Automation Scripts on Junos Devices
- Overview of Python Modules on Junos Devices
- How to Use Python Interactive Mode on Devices Running Junos OS
- How to Use the psutil Module to Retrieve Process and System Information on Devices Running Junos OS
- How to Use the Requests Library for Python on Devices Running Junos OS
- IPv6 Support in Python Automation Scripts
- How to Specify the Routing Instance in Python 3 Applications on Devices Running Junos OS Evolved
-
- play_arrow Automation Script Input
- play_arrow Global Parameters in Automation Scripts
-
- play_arrow Extension Functions and Named Templates for Automation Scripts
- play_arrow Extension Functions for Automation Scripting
- play_arrow Extension Functions in the jcs and slax Namespaces
- base64-decode() Function (SLAX)
- base64-encode() Function (SLAX)
- break-lines() Function (SLAX and XSLT)
- close() Function (SLAX and XSLT)
- dampen() Function (Python, SLAX, and XSLT)
- document() Function (SLAX)
- emit_error() Function (Python)
- emit_snmp_attributes Function (Python)
- emit_warning() Function (Python)
- empty() Function (SLAX and XSLT)
- evaluate() Function (SLAX)
- execute() Function (SLAX and XSLT)
- first-of() Function (SLAX and XSLT)
- get-command() Function (SLAX)
- get-hello() Function (SLAX and XSLT)
- get-input() Function (SLAX and XSLT) and get_input() (Python)
- get-protocol() Function (SLAX and XSLT)
- get-secret() Function (SLAX and XSLT) and get_secret() (Python)
- get_snmp_action() Function (Python)
- get_snmp_oid() Function (Python)
- hostname() Function (Python, SLAX, and XSLT)
- invoke() Function (SLAX and XSLT)
- open() Function (SLAX and XSLT)
- output() Function (Python, SLAX, and XSLT)
- parse-ip() Function (SLAX and XSLT) and parse_ip() (Python)
- printf() Function (Python, SLAX, and XSLT)
- progress() Function (Python, SLAX, and XSLT)
- regex() Function (SLAX and XSLT)
- set_routing_instance() Function (Python)
- sleep() Function (SLAX and XSLT)
- split() Function (SLAX and XSLT)
- sysctl() Function (Python, SLAX, and XSLT)
- syslog() Function (Python, SLAX, and XSLT)
- trace() Function (Python, SLAX, and XSLT)
- play_arrow Named Templates for Automation Scripting
- play_arrow Named Templates in the jcs Namespace
-
- play_arrow Manage Automation Scripts
- play_arrow Store and Enable Scripts
- play_arrow Configure a Remote Source for Scripts
- play_arrow Configure the Session Protocol for Scripts
- play_arrow Control Execution of Scripts
- play_arrow Synchronize Scripts Between Routing Engines
- play_arrow Convert Scripts Between SLAX and XSLT
-
- play_arrow Commit Scripts
- play_arrow Commit Scripts Overview
- play_arrow Create and Execute Commit Scripts
- Required Boilerplate for Commit Scripts
- XML Syntax for Common Commit Script Tasks
- Design Considerations for Commit Scripts
- How to Avoid Potential Conflicts When Using Multiple Commit Scripts
- Line-by-Line Explanation of Sample Commit Scripts
- Control the Execution of Commit Scripts During Commit Operations
- Control the Execution of Commit Scripts in the QFabric System
- Configure Checksum Hashes for a Commit Script
- How to Process Large Configurations Against Commit Scripts
- Example: Retrieve the Pre-Inheritance Candidate Configuration in a Commit Script
- play_arrow Generate a Custom Warning, Error, or System Log Message Using Commit Scripts
- Overview of Generating Custom Warning, Error, and System Log Messages
- Generate a Custom Warning, Error, or System Log Message in Commit Scripts
- SLAX and XSLT Commit Script Tag Elements to Use When Generating Messages
- Example: Generate a Custom Warning Message
- Example: Generate a Custom Error Message
- Example: Generate a Custom System Log Message
- play_arrow Generate Persistent or Transient Configuration Changes Using Commit Scripts
- Overview of Generating Persistent or Transient Configuration Changes Using Commit Scripts
- Generate a Persistent or Transient Configuration Change in SLAX and XSLT Commit Scripts
- Generate a Persistent or Transient Configuration Change in Python Commit Scripts
- SLAX and XSLT Commit Script Tag Elements to Use When Generating Persistent and Transient Configuration Changes
- Remove a Persistent or Transient Configuration Change Using Commit Scripts
- Example: Generate Persistent and Transient Configuration Changes Using Commit Scripts
- play_arrow Create Custom Configuration Syntax with Commit Script Macros
- Overview of Creating Custom Configuration Syntax with Commit Script Macros
- Create Custom Configuration Syntax with Commit Script Macros
- Create a Commit Script Macro to Read the Custom Syntax and Generate Related Configuration Statements
- Example: Creating Custom Configuration Syntax with Commit Script Macros
- play_arrow Commit Script Examples
- Example: Adding a Final then accept Term to a Firewall
- Example: Adding T1 Interfaces to a RIP Group
- Example: Assign a Classifier Using a Commit Script
- Example: Automatically Configure Logical Interfaces and IP Addresses
- Example: Configure Administrative Groups for LSPs
- Example: Configure a Default Encapsulation Type
- Example: Configure Dual Routing Engines
- Example: Configure an Interior Gateway Protocol on an Interface
- Example: Control IS-IS and MPLS Interfaces
- Example: Control LDP Configuration
- Example: Create a Complex Configuration Based on a Simple Interface Configuration
- Example: Impose a Minimum MTU Setting
- Example: Limit the Number of ATM Virtual Circuits
- Example: Limit the Number of E1 Interfaces
- Example: Load a Base Configuration
- Example: Prepend a Global Policy
- Example: Prevent Import of the Full Routing Table
- Example: Require Internal Clocking on T1 Interfaces
- Example: Require and Restrict Configuration Statements
- play_arrow Junos XML and XSLT Tag Elements Used in Commit Scripts
- play_arrow Troubleshoot Commit Scripts
-
- play_arrow Event Policies and Event Scripts
- play_arrow Event Policy Overview
- play_arrow Event Policy Triggers
- Use Correlated Events to Trigger an Event Policy
- Trigger an Event Policy Based on Event Count
- Example: Trigger an Event Policy Based on Event Count
- Use Regular Expressions to Refine the Set of Events That Trigger a Policy
- Example: Controlling Event Policy Using a Regular Expression
- Generate Internal Events to Trigger Event Policies
- Use Nonstandard System Log Messages to Trigger Event Policies
- Junos Logger Utility
- play_arrow Event Policy Actions
- Configure an Event Policy to Execute Operational Mode Commands
- Configure an Event Policy to Change the Configuration
- Example: Changing the Configuration Using an Event Policy
- Example: Changing the Interface Configuration in Response to an Event
- Execute Event Scripts in an Event Policy
- Change the Configuration Using an Event Script
- Configuring an Event Policy to Pass Arguments to an Event Script
- Configure Event Policies to Ignore an Event
- Example: Ignore Events Based on Receipt of Other Events
- Overview of Using Event Policies to Raise SNMP Traps
- Example: Raise an SNMP Trap in Response to an Event
- Understanding the Event System Log Priority in an Event Policy
- Example: Configuring the Event System Log Priority in an Event Policy
- Example: Limit Event Script Output Based on a Specific Event Type
- play_arrow Configure Event Policy File Archiving
- play_arrow Configure Event Policy Privileges
- play_arrow Event Scripts Overview
- play_arrow Create and Execute Event Scripts
- play_arrow Troubleshoot Event Policies and Event Scripts
-
- play_arrow SNMP Scripts
- play_arrow SNMP Scripts Overview
- play_arrow Create and Execute SNMP Scripts
- play_arrow SNMP Script Example
- play_arrow Troubleshoot SNMP Scripts
-
- play_arrow Configuration Statements and Operational Commands
Change the Configuration Using SLAX and XSLT Scripts
SLAX and XSLT op and event scripts can use the jcs:load-configuration template to make structured changes to the Junos OS
configuration. Experienced users, who are familiar with Junos OS,
can write scripts that prompt for the relevant configuration information
and modify the configuration accordingly. This enables users who have
less experience with Junos OS to safely modify the configuration using
the script.
This topic discusses how to use the jcs:load-configuration template to modify the configuration.
jcs:load-configuration Template Overview
The jcs:load-configuration template
is included in the junos.xsl import
file. The template can:
Load Junos XML configuration data into the candidate configuration using a
load merge,load replace, orload overrideoperation and commit the changesRoll back the active configuration to a previously committed configuration
Load and commit the rescue configuration
When called, the jcs:load-configuration template performs the following actions on the target device:
Locks the configuration database
Loads the configuration changes
Commits the configuration
Unlocks the configuration database
The jcs:load-configuration template
makes changes to the configuration in configure exclusive mode. In this mode, Junos OS locks the candidate global configuration for as long as the script accesses the shared database
and makes changes to the configuration. The template call might fail
if the configuration database is already locked or if there are existing,
uncommitted changes in the candidate configuration when the template
is called. If the template successfully loads the configuration data,
but the commit fails, Junos OS discards the uncommitted changes when
the database is unlocked.
The SLAX template syntax is:
call jcs:load-configuration($action="(merge | override | replace)", $commit-options=node-set, $configuration=configuration-data, $connection=connection-handle, $rescue="rescue", $rollback=number);
The XSLT template syntax is:
<xsl:call-template name="jcs:load-configuration">
<xsl:with-param name="action" select="(merge | override | replace)"/>
<xsl:with-param name="commit-options" select="node-set"/>
<xsl:with-param name="configuration" select="configuration-data"/>
<xsl:with-param name="connection" select="connection-handle"/>
<xsl:with-param name="rescue" select=""rescue""/>
<xsl:with-param name="rollback" select="number"/>
</xsl:call-template>
You provide arguments to the jcs:load-configuration template to specify:
the connection handle to the device on which the changes will be made
the changes to make to the configuration
the load action that defines how to integrate the changes into the existing configuration
optional commit options
You must establish a connection with the target device before
calling the jcs:load-configuration template.
To connect to a device, call the jcs:open() function with the necessary arguments. Then set the jcs:load-configuration connection parameter to the handle returned by the jcs:open() function.
The following sample code connects to the local device and modifies the configuration:
var $conn = jcs:open();
var $results := {
call jcs:load-configuration($configuration=$config-changes, $connection=$conn);
}
var $close-results = jcs:close($conn);
When you call the jcs:load-configuration template, you can include the configuration parameter to load new configuration data on a device, you can specify
the rollback parameter to revert the configuration
to a previously committed configuration, or you can specify the rescue parameter to load and commit the rescue configuration.
Loading and Committing Configuration Data
SLAX and XSLT scripts can call the jcs:load-configuration template to modify the configuration. The configuration parameter defines the Junos XML configuration data to load, and
the action parameter specifies how to load
the data. The commit-options parameter
defines the options to use during the commit operation.
The following sample op script calls the jcs:load-configuration template to modify the configuration to disable an interface. All
of the values required for the jcs:load-configuration template are defined as variables, which are then passed into the
template as arguments.
The := operator copies the results
of the jcs:load-configuration template
call to a temporary variable and runs the node-set function on that variable. The := operator
ensures that the disable-results variable
is a node-set rather than a result tree fragment so that the script
can access the contents.
SLAX syntax:
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";
ns ext = "http://xmlsoft.org/XSLT/namespace";
import "../import/junos.xsl";
match / {
<op-script-results> {
var $interface = jcs:get-input("Enter interface to disable: ");
var $config-changes = {
<configuration> {
<interfaces> {
<interface> {
<name> $interface;
<disable>;
}
}
}
}
var $load-action = "merge";
var $options := {
<commit-options> {
<synchronize>;
<log> "disabling interface " _ $interface;
}
}
var $conn = jcs:open();
var $results := {
call jcs:load-configuration($action=$load-action, $commit-options=$options,
$configuration=$config-changes, $connection=$conn);
}
if ($results//xnm:error) {
for-each ($results//xnm:error) {
<output> message;
}
}
var $close-results = jcs:close($conn);
}
}For detailed information about this script, see Example: Change the Configuration Using SLAX and XSLT Op Scripts.
The equivalent XSLT code for the call to the jcs:load-configuration template is:
<xsl:variable name="disable-results-temp">
<xsl:call-template name="jcs:load-configuration">
<xsl:with-param name="action" select="$load-action"/>
<xsl:with-param name="commit-options" select="$options"/>
<xsl:with-param name="configuration" select="$disable"/>
<xsl:with-param name="connection" select="$conn"/>
</xsl:call-template>
</xsl:variable>
<xsl:variable xmlns ext="http:xmlsoft.org/XSLT/namespace" \
name="disable-results" select="ext:node-set($disable-results-temp)"/>
Loading and Committing the Rescue Configuration
A rescue configuration allows you to define a known working
configuration or a configuration with a known state that you can restore
at any time. SLAX and XSLT scripts can call the jcs:load-configuration template with the rescue parameter to
load the rescue configuration, if one exists.
The following SLAX op script loads and commits the existing rescue configuration.
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 "/var/db/scripts/import/junos.xsl";
match / {
<op-script-results> {
/* Open the connection */
var $conn = jcs:open();
/* Load and commit the rescue configuration */
var $results = {
call jcs:load-configuration($connection=$conn, $rescue="rescue");
}
expr jcs:output($results);
/* Close the connection */
expr jcs:close($conn);
}
}
The equivalent XSLT script is:
<?xml version="1.0" standalone="yes"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:junos="http://xml.juniper.net/junos/*/junos"
xmlns:xnm="http://xml.juniper.net/xnm/1.1/xnm"
xmlns:jcs="http://xml.juniper.net/junos/commit-scripts/1.0" version="1.0">
<xsl:import href="/var/db/scripts/import/junos.xsl"/>
<xsl:template match="/">
<op-script-results>
<!-- Open the connection -->
<xsl:variable name="conn" select="jcs:open()"/>
<!-- Load and commit the rescue configuration -->
<xsl:variable name="results">
<xsl:call-template name="jcs:load-configuration">
<xsl:with-param name="connection" select="$conn"/>
<xsl:with-param name="rescue" select=""rescue""/>
</xsl:call-template>
</xsl:variable>
<xsl:value-of select="jcs:output($results)"/>
<!-- Close the connection -->
<xsl:value-of select="jcs:close($conn)"/>
</op-script-results>
</xsl:template>
</xsl:stylesheet>
Rolling Back the Configuration
SLAX and XSLT scripts can call the jcs:load-configuration template with the rollback parameter
to revert the configuration to a previously committed configuration.
The following SLAX op script prompts for the rollback number, and
then loads the requested rollback configuration and commits it.
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 / {
<op-script-results> {
var $rollback_id = jcs:get-input("Rollback id: ");
/* Open the connection */
var $conn = jcs:open();
/* Roll back the configuration and commit it */
var $results = {
call jcs:load-configuration($connection=$conn, $rollback=$rollback_id);
}
/* Close the connection */
expr jcs:close($conn);
}
}user@host> op load-rollback Rollback id: 1
