Declare and Use Command-Line Arguments in Op Scripts

How to Define Arguments in the Op Script

You can declare an op script's expected command-line arguments directly in the Python, SLAX, or XSLT op script.

To declare command-line arguments in Python op scripts:

1. Declare a global dictionary named arguments.
2. For each argument, define a name-value pair that maps to the argument name and argument help text.

Python Syntax

# Define arguments dictionary
arguments = {'name1': 'description1', 'name2': 'description2'}

if __name__ == '__main__':
    ...

To declare command-line arguments in SLAX or XSLT op scripts:

1. Declare a global variable named arguments.
2. For each argument, define an <argument> element.
3. Within each <argument> element:
   • Define the <name> element with the name of the argument.
   • Optionally define a <description> element that provides the help text for that argument.

XSLT Syntax

<xsl:variable name="arguments">
    <argument>
        <name>name</name>
        <description>descriptive-text</description>
    </argument>
</xsl:variable>

SLAX Syntax

var $arguments = {
    <argument> {
        <name> "name";
        <description> "descriptive-text";
    }
}

How to Define Arguments in the Junos OS Configuration

You can declare an op script's expected command-line arguments in the Junos OS configuration, as an alternative to declaring the arguments directly in the op script.

To declare command-line arguments in the configuration:

1. Navigate to the arguments statement at the [edit system scripts op file filename] hierarchy level for the given script.
2. Configure the argument name.
3. Optionally configure the description statement to provide the help text for the argument.

For example:

[edit system scripts op op file file filename]
arguments {
    argument-name {
        description descriptive-text;
    }
}

How to Display Arguments in the Context-Sensitive Help

After you declare arguments in either the op script or the configuration, you can use the CLI's context-sensitive help to list the op script arguments. If you include the optional argument description, the CLI displays the help text with the argument name.

user@host> op filename ?
Possible completions:
  argument-name        description
  argument-name        description

You can also create a hidden argument for an op script by not including the argument declaration in the op script or the configuration. You use the argument as you normally would in the script, but the CLI does not display the argument or help text when you request context-sensitive help for that op script.

For more information about configuring help text for op scripts, see Configure Help Text for Op Scripts.

How to Use Arguments in Python Op Scripts

Python op scripts can use standard command-line parsing libraries to process and use command-line arguments. For example, you can use the Python argparse library to easily define required and optional arguments, specify default values, and handle the arguments in the script.

To enable users to more easily use the standard Python libraries to parse command-line arguments, we modified the way that the arguments are passed to Python op scripts. Starting in Junos OS Release 21.2R1 and Junos OS Evolved Release 21.2R1, when the device passes command-line arguments to a Python op script, it prefixes a single hyphen (-) to single-character argument names and prefixes two hyphens (--) to multi-character argument names. In earlier releases, the devices prefixes a single hyphen (-) to all argument names. You should ensure that your op script properly handles the arguments for your specific release.

The following examples use the argparse module to handle the script arguments. The examples define the global arguments dictionary, and the dictionary keys are used to define the expected arguments for the parser. We provide two example scripts, which appropriately handle the arguments in the specified releases.

Python Syntax (Junos OS Release 21.2R1 or later)

# Junos OS Release 21.2R1 and later
import argparse

arguments = {'arg1': 'description1', 'arg2': 'description2', 's': 'short option'}

def main():
    parser = argparse.ArgumentParser(description='This is a demo script.')

    # Define the arguments accepted by parser
    #  which use the key names defined in the arguments dictionary
    for key in arguments:
        if len(key) == 1:
            parser.add_argument(('-' + key), required=True, help=arguments[key])
        else:
            parser.add_argument(('--' + key), required=True, help=arguments[key])
    args = parser.parse_args()

    # Extract the value
    print (args.arg1)
    print (args.arg2)
    print (args.s)

if __name__ == '__main__':
    main()

Python Syntax (Junos OS Release 21.1 and earlier)

# Junos OS Release 21.1 and earlier
import argparse

arguments = {'arg1': 'description1', 'arg2': 'description2', 's': 'short option'}

def main():
    parser = argparse.ArgumentParser(description='This is a demo script.')

    # Define the arguments accepted by parser
    #  which use the key names defined in the arguments dictionary
    for key in arguments:
        parser.add_argument(('-' + key), required=True, help=arguments[key])
    args = parser.parse_args()

    # Extract the value
    print (args.arg1)
    print (args.arg2)
    print (args.s)

if __name__ == '__main__':
    main()

How to Use Arguments in SLAX and XSLT Op Scripts

To use command-line arguments in SLAX or XSLT op scripts, you must:

1. Include a parameter declaration for each argument
2. Ensure the parameter name is identical to the name that you defined in either the arguments variable declaration in the script or the arguments statement in the Junos OS configuration.

XSLT Syntax

<xsl:param name="name"/>

SLAX Syntax

param $name;

The op script assigns the value for each script argument to the corresponding parameter, which can then be referenced throughout the script.