Declarar y usar argumentos de línea de comandos en scripts operativos
Los scripts operativos de Junos OS pueden aceptar argumentos de línea de comandos cuando se invoca el script. Puede incluir declaraciones en el script op o instrucciones en la configuración que permiten a un usuario ver la lista de argumentos posibles cuando solicita ayuda sensible al contexto para el script op en la CLI. El script también debe incluir las declaraciones y el código necesarios para procesar esos argumentos. En las siguientes secciones se detalla cómo definir los argumentos, el texto de ayuda y el uso de los argumentos en una secuencia de comandos de op.
Declaración de argumentos de línea de comandos de secuencia de comandos op
Hay dos maneras de definir la lista de argumentos de scripts operativos esperados que se mostrarán cuando se utilice ayuda sensible al contexto en la CLI:
-
Incluir declaraciones en el script operativo
-
Incluir instrucciones en la configuración de Junos OS
Los argumentos generados por scripts y por configuración tienen el mismo impacto operativo. En las siguientes secciones se explica cómo usar los diferentes métodos para definir los argumentos de script op y mostrarlos en la CLI:
- Cómo definir argumentos en el script operativo
- Cómo definir argumentos en la configuración de Junos OS
- Cómo mostrar argumentos en la Ayuda sensible al contexto
Cómo definir argumentos en el script operativo
Puede declarar los argumentos de línea de comandos esperados de una secuencia de comandos op directamente en la secuencia de comandos de Python, SLAX o XSLT op.
Para declarar argumentos de línea de comandos en scripts operativos de Python:
- Declare un diccionario global denominado
arguments. - Para cada argumento, defina un par nombre-valor que se asigne al nombre del argumento y al texto de ayuda del argumento.
Sintaxis de Python
# Define arguments dictionary
arguments = {'name1': 'description1', 'name2': 'description2'}
if __name__ == '__main__':
...
Para mostrar los argumentos en la CLI, los scripts de Python deben incluir la if __name__ == '__main__': instrucción.
Para declarar argumentos de línea de comandos en scripts operativos SLAX o XSLT:
- Declare una variable global denominada
arguments. - Para cada argumento, defina un
<argument>elemento. - Dentro de cada
<argument>elemento:- Defina el
<name>elemento con el nombre del argumento. - Si lo desea, defina un
<description>elemento que proporcione el texto de ayuda para ese argumento.
- Defina el
Sintaxis XSLT
<xsl:variable name="arguments"> <argument> <name>name</name> <description>descriptive-text</description> </argument> </xsl:variable>
Sintaxis SLAX
var $arguments = {
<argument> {
<name> "name";
<description> "descriptive-text";
}
}
Cómo definir argumentos en la configuración de Junos OS
Puede declarar los argumentos de línea de comandos esperados de una secuencia de comandos op en la configuración de Junos OS, como alternativa a declarar los argumentos directamente en la secuencia de comandos op.
Para declarar argumentos de línea de comandos en la configuración:
- Vaya a la
argumentsinstrucción en el[edit system scripts op file filename]nivel de jerarquía para la secuencia de comandos dada. - Configure el nombre del argumento.
- Si lo desea, configure la
descriptioninstrucción para que proporcione el texto de ayuda para el argumento.
Por ejemplo:
[edit system scripts op op file file filename] arguments { argument-name { description descriptive-text; } }
Cómo mostrar argumentos en la Ayuda sensible al contexto
Después de declarar argumentos en el script op o en la configuración, puede usar la ayuda sensible al contexto de la CLI para enumerar los argumentos de script op. Si incluye la descripción del argumento opcional, la CLI muestra el texto de ayuda con el nombre del argumento.
user@host> op filename ? Possible completions: argument-name description argument-name description
También puede crear un argumento oculto para una secuencia de comandos op al no incluir la declaración de argumento en el script op o la configuración. Se usa el argumento como lo haría normalmente en la secuencia de comandos, pero la CLI no muestra el argumento ni el texto de ayuda cuando solicita ayuda sensible al contexto para ese script operativo.
Si configura argumentos de línea de comandos en la configuración de Junos OS y también declara argumentos directamente en la secuencia de comandos op, los argumentos que declara en la secuencia de comandos siguen estando disponibles, pero la CLI no los Possible completions enumera en cuando se emite el op filename ? comando. Esto se produce porque el proceso de administración (mgd) rellena la lista comprobando primero la configuración para los argumentos. El proceso mgd comprueba el script para argumentos solo si no se encuentra ningún argumento en la configuración. Por lo tanto, si declara argumentos en la configuración, todos los argumentos declarados en la secuencia de comandos se ocultan en la CLI.
Para obtener más información acerca de cómo configurar texto de ayuda para scripts operativos, consulte Configurar texto de ayuda para scripts operativos.
Uso de argumentos de línea de comandos en scripts operativos
Puede ejecutar scripts operativos locales con el op filename comando. Para pasar argumentos de línea de comandos a la secuencia de comandos, incluya el nombre y el valor de cada argumento cuando ejecute la secuencia de comandos.
user@host> op filename argument-name argument-value
Si especifica un argumento que la secuencia de comandos no reconoce, el script ignora el argumento.
En las siguientes secciones se explica cómo usar los argumentos de línea de comandos que se pasan a los scripts op de Python, SLAX y XSLT:
- Cómo usar argumentos en scripts operativos de Python
- Cómo usar argumentos en scripts operativos SLAX y XSLT
Cómo usar argumentos en scripts operativos de Python
Los scripts operativos de Python pueden usar bibliotecas estándar de análisis de línea de comandos para procesar y usar argumentos de línea de comandos. Por ejemplo, puede usar la biblioteca python argparse para definir fácilmente argumentos necesarios y opcionales, especificar valores predeterminados y controlar los argumentos en la secuencia de comandos.
Para permitir a los usuarios usar con mayor facilidad las bibliotecas estándar de Python para analizar argumentos de línea de comandos, modificamos la forma en que los argumentos se pasan a scripts op de Python. A partir de Junos OS versión 21.2R1 y Junos OS Evolved versión 21.2R1, cuando el dispositivo pasa argumentos de línea de comandos a una secuencia de comandos de Python op script, prefija un guión único (-) a nombres de argumentos de un solo carácter y prefijos dos guiones (--) a nombres de argumentos de varios caracteres. En versiones anteriores, los dispositivos prefijan un único guión (-) a todos los nombres de argumentos. Debe asegurarse de que la secuencia de comandos op maneje correctamente los argumentos de su versión específica.
Los siguientes ejemplos usan el argparse módulo para controlar los argumentos de script. Los ejemplos definen el diccionario global arguments y las claves del diccionario se utilizan para definir los argumentos esperados para el analizador. Proporcionamos dos scripts de ejemplo, que manejan adecuadamente los argumentos de las versiones especificadas.
Sintaxis de Python (Junos OS versión 21.2R1 o posterior)
# 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()
Sintaxis de Python (Junos OS versión 21.1 y anteriores)
# 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()
Cómo usar argumentos en scripts operativos SLAX y XSLT
Para usar argumentos de línea de comandos en scripts operativos SLAX o XSLT, debe:
- Incluir una declaración de parámetro para cada argumento
- Asegúrese de que el nombre del parámetro es idéntico al nombre que definió en la declaración de variable
argumentsen el script o en laargumentsinstrucción en la configuración de Junos OS.
Sintaxis XSLT
<xsl:param name="name"/>
Sintaxis SLAX
param $name;
La secuencia de comandos op asigna el valor de cada argumento de secuencia de comandos al parámetro correspondiente, que luego se puede hacer referencia a todo el script.
Ejemplo: Declaración de argumentos en scripts operativos de XSLT
Declare dos argumentos denominados interface y protocol. Ejecute el script especificando la interfaz ge-0/2/0.0 y el inet protocolo como valores para los argumentos.
En los ejemplos siguientes, se muestra cómo declarar los argumentos en la secuencia de comandos XSLT o en la configuración:
Declaración de argumentos en la secuencia de comandos operativo (script1)
<xsl:variable name="arguments"> <argument> <name>interface</name> <description>Name of interface to display</description> </argument> <argument> <name>protocol</name> <description>Protocol to display (inet, inet6)</description> </argument> </xsl:variable>
Declaración de argumentos en la configuración
[edit system scripts op]
file script1 {
arguments {
interface {
description "Name of interface to display";
}
protocol {
description "Protocol to display (inet, inet6)";
}
}
}
Además de declarar los argumentos en la secuencia de comandos o la configuración, también debe declarar los parámetros correspondientes en la secuencia de comandos para hacer referencia a los argumentos de script y acceder a sus valores.
Declarar los parámetros
<xsl:param name="interface"/> <xsl:param name="protocol"/>
Proporcione los nombres y valores de argumentos al ejecutar la secuencia de comandos. Por ejemplo:
Ejecución del script
user@host> op script1 interface ge-0/2/0.0 protocol inet
Ejemplo: Declaración y uso de argumentos en scripts operativos de Python
Declare dos argumentos con nombre interface y p en la secuencia de comandos op de Python. Ejecute el script especificando la interfaz ge-0/2/0.0 y el inet protocolo como valores para los argumentos. Seleccione las instrucciones de manejo de argumentos adecuadas según su versión. El script usa instrucciones compatibles con la versión 21.2R1 y posteriores de Junos OS, y comenta las instrucciones para manejar argumentos en versiones anteriores.
Declaración de argumentos en la secuencia de comandos op (script1.py)
from jnpr.junos import Device
import argparse
# Define arguments dictionary
arguments = {'interface': 'Name of interface to display', 'p': 'Protocol to display (inet, inet6)'}
def main():
parser = argparse.ArgumentParser()
# Argument handling for Junos OS Release 21.2R1 or later
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])
# Argument handling for Junos OS Release 21.1 and earlier
#for key in arguments:
# parser.add_argument(('-' + key), required=True, help=arguments[key])
args = parser.parse_args()
try:
with Device() as dev:
res = dev.rpc.get_interface_information(
interface_name=args.interface, terse=True, normalize=True)
print (args.interface + " status: " +
res.findtext("logical-interface/oper-status"))
for elem in res.xpath("//address-family \
[normalize-space(address-family-name)=$protocol]",
protocol=args.p):
if (elem.find("interface-address/ifa-local") is not None):
print ("inet address: " +
elem.find("interface-address/ifa-local").text)
except Exception as err:
print (err)
if __name__ == '__main__':
main()
Alternativamente, en lugar de incluir el arguments diccionario en la secuencia de comandos op de Python, puede incluir los argumentos en la configuración exactamente como lo haría para los scripts SLAX y XSLT.
Para ver los argumentos de script op en la ayuda sensible al contexto de la CLI, emita el op filename ? comando.
Mostrar los argumentos
user@host> op script1.py ? Possible completions: <[Enter]> Execute this command <name> Argument name detail Display detailed output interface Name of interface to display invoke-debugger Invoke script in debugger mode p Protocol to display (inet, inet6) | Pipe through a command
Proporcione los nombres y valores de argumentos al ejecutar la secuencia de comandos. Por ejemplo:
Ejecución del script
user@host> op script1.py interface ge-0/2/0.0 p inet ge-0/2/0.0 status: up inet address 198.51.100.1/24