Déclarer et utiliser des arguments de ligne de commande dans les scripts Op
Les scripts op Junos OS peuvent accepter des arguments de ligne de commande lorsque vous appelez le script. Vous pouvez inclure des déclarations dans le script op ou des déclarations dans la configuration qui permettent à un utilisateur de voir la liste des arguments possibles lorsqu’il demande une aide contextuelle pour le script op dans l’interface de ligne de commande. Le script doit également inclure toutes les déclarations et le code nécessaires pour traiter ces arguments. Les sections suivantes détaillent comment définir les arguments et le texte d’aide et utiliser les arguments dans un script op.
Déclaration des arguments de ligne de commande de script Op
Il existe deux façons de définir la liste des arguments attendus des scripts op qui seront affichés lors de l’utilisation d’une aide contextuelle dans la CLI :
-
Inclure des déclarations dans le script op
-
Inclure des instructions dans la configuration Junos OS
Les arguments générés par les scripts et les arguments générés par la configuration ont le même impact opérationnel. Les sections suivantes expliquent comment utiliser les différentes méthodes pour définir les arguments de script op et les afficher dans la CLI :
- Comment définir des arguments dans le script Op
- Comment définir des arguments dans la configuration junos OS
- Comment afficher des arguments dans l’aide contextuelle
Comment définir des arguments dans le script Op
Vous pouvez déclarer les arguments de ligne de commande attendus d’un script op directement dans le script d’exploitation Python, SLAX ou XSLT.
Pour déclarer les arguments de ligne de commande dans les scripts Op Python :
- Déclarer un dictionnaire global nommé
arguments. - Pour chaque argument, définissez une paire nom-valeur qui correspond au texte d’aide de l’argument et du nom de l’argument.
Syntaxe Python
# Define arguments dictionary
arguments = {'name1': 'description1', 'name2': 'description2'}
if __name__ == '__main__':
...
Pour afficher les arguments dans la CLI, les scripts Python doivent inclure l’instruction if __name__ == '__main__': .
Pour déclarer les arguments de ligne de commande dans les scripts d’exploitation SLAX ou XSLT :
- Déclarez une variable globale nommée
arguments. - Pour chaque argument, définissez un
<argument>élément. - Au sein de chaque
<argument>élément :- Définissez l’élément
<name>avec le nom de l’argument. - Définissez éventuellement un
<description>élément qui fournit le texte d’aide pour cet argument.
- Définissez l’élément
Syntaxe XSLT
<xsl:variable name="arguments"> <argument> <name>name</name> <description>descriptive-text</description> </argument> </xsl:variable>
Syntaxe SLAX
var $arguments = {
<argument> {
<name> "name";
<description> "descriptive-text";
}
}
Comment définir des arguments dans la configuration junos OS
Vous pouvez déclarer les arguments de ligne de commande attendus d’un script op dans la configuration Junos OS, au remplacement de la déclaration des arguments directement dans le script op.
Pour déclarer les arguments de ligne de commande dans la configuration :
- Accédez à l’instruction
argumentsau niveau de la[edit system scripts op file filename]hiérarchie pour le script donné. - Configurez le nom de l’argument.
- Configurez éventuellement l’instruction
descriptionpour qu’elle fournisse le texte d’aide de l’argument.
Par exemple :
[edit system scripts op op file file filename] arguments { argument-name { description descriptive-text; } }
Comment afficher des arguments dans l’aide contextuelle
Une fois que vous avez déclaré des arguments dans le script op ou dans la configuration, vous pouvez utiliser l’aide contextuelle de l’interface cli pour lister les arguments de script op. Si vous incluez la description optionnelle de l’argument, la CLI affiche le texte d’aide avec le nom de l’argument.
user@host> op filename ? Possible completions: argument-name description argument-name description
Vous pouvez également créer un argument masqué pour un script op en n’incluant pas la déclaration d’argument dans le script op ou la configuration. Vous utilisez l’argument comme vous le feriez normalement dans le script, mais l’interface CLI n’affiche pas l’argument ou le texte d’aide lorsque vous demandez une aide contextuelle pour ce script op.
Si vous configurez des arguments de ligne de commande dans la configuration Junos OS et déclarez également des arguments directement dans le script op, les arguments que vous déclarez dans le script sont toujours disponibles, mais l’interface cli ne les répertorie pas sous Possible completions lorsque vous émettez la op filename ? commande. Cela se produit parce que le processus de gestion (mgd) remplit la liste en vérifiant d’abord la configuration à la recherche d’arguments. Le processus mgd vérifie la recherche d’arguments dans le script uniquement si aucun argument n’est trouvé dans la configuration. Ainsi, si vous déclarez des arguments dans la configuration, tous les arguments déclarés dans le script deviennent cachés dans la CLI.
Pour plus d’informations sur la configuration du texte d’aide pour les scripts op, voir Configurer le texte d’aide pour les scripts op.
Utilisation d’arguments de ligne de commande dans les scripts Op
Vous exécutez des scripts op locaux avec la op filename commande. Pour transmettre les arguments de ligne de commande au script, incluez chaque argument nom et valeur lorsque vous exécutez le script.
user@host> op filename argument-name argument-value
Si vous spécifiez un argument que le script ne reconnaît pas, il ignore l’argument.
Les sections suivantes expliquent comment utiliser les arguments de ligne de commande qui sont transmis aux scripts d’exploitation Python, SLAX et XSLT :
- Comment utiliser des arguments dans les scripts Python Op
- Comment utiliser des arguments dans les scripts OP SLAX et XSLT
Comment utiliser des arguments dans les scripts Python Op
Les scripts op Python peuvent utiliser des bibliothèques d’analyse de ligne de commande standard pour traiter et utiliser des arguments de ligne de commande. Par exemple, vous pouvez utiliser la bibliothèque Python argparse pour définir facilement les arguments requis et facultatifs, spécifier des valeurs par défaut et gérer les arguments dans le script.
Pour permettre aux utilisateurs d’utiliser plus facilement les bibliothèques Python standard pour analyser les arguments de ligne de commande, nous avons modifié la façon dont les arguments sont transmis aux scripts op Python. À partir de La version 21.2R1 de Junos OS et de la version 21.2R1 de Junos OS Evolved, lorsque l’équipement transmet des arguments de ligne de commande à un script Python op, il préfixe un seul trait d’union (-) vers des noms d’arguments à caractère unique et préfixe deux traits d’union (--) à des noms d’arguments multi-caractères. Dans les versions précédentes, les équipements préfixent un seul trait d’union (-) à tous les noms d’arguments. Vous devez vous assurer que votre script op gère correctement les arguments de votre version spécifique.
Les exemples suivants utilisent le argparse module pour gérer les arguments de script. Les exemples définissent le dictionnaire global arguments , et les clés de dictionnaire sont utilisées pour définir les arguments attendus pour l’analyseur. Nous fournissons deux exemples de scripts, qui gèrent correctement les arguments dans les versions spécifiées.
Syntaxe Python (Junos OS version 21.2R1 ou ultérieure)
# 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()
Syntaxe Python (Junos OS version 21.1 et versions antérieures)
# 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()
Comment utiliser des arguments dans les scripts OP SLAX et XSLT
Pour utiliser des arguments de ligne de commande dans les scripts d’exploitation SLAX ou XSLT, vous devez :
- Inclure une déclaration de paramètres pour chaque argument
- Assurez-vous que le nom du paramètre est identique au nom que vous avez défini dans la
argumentsdéclaration de variable dans le script ouargumentsl’instruction dans la configuration Junos OS.
Syntaxe XSLT
<xsl:param name="name"/>
Syntaxe SLAX
param $name;
Le script op attribue la valeur de chaque argument de script au paramètre correspondant, qui peut ensuite être référencé dans l’ensemble du script.
Exemple : déclaration d’arguments dans les scripts D’exploitation XSLT
Déclarez deux arguments nommés interface et protocol. Exécutez le script en spécifiant l’interface ge-0/2/0.0 et le inet protocole comme valeurs pour les arguments.
Les exemples suivants montrent comment déclarer les arguments dans le script XSLT ou dans la configuration :
Déclaration d’arguments dans le script Op (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>
Déclaration des arguments dans la configuration
[edit system scripts op]
file script1 {
arguments {
interface {
description "Name of interface to display";
}
protocol {
description "Protocol to display (inet, inet6)";
}
}
}
En plus de déclarer les arguments dans le script ou la configuration, vous devez également déclarer les paramètres correspondants dans le script afin de référencer les arguments de script et d’accéder à leurs valeurs.
Déclaration des paramètres
<xsl:param name="interface"/> <xsl:param name="protocol"/>
Indiquez les noms et les valeurs de l’argument lorsque vous exécutez le script. Par exemple :
Exécution du script
user@host> op script1 interface ge-0/2/0.0 protocol inet
Exemple : déclaration et utilisation d’arguments dans des scripts Python Op
Déclarez deux arguments nommés interface et p dans le script Python op. Exécutez le script en spécifiant l’interface ge-0/2/0.0 et le inet protocole comme valeurs pour les arguments. Sélectionnez les déclarations de traitement des arguments appropriées en fonction de votre version. Le script utilise des instructions compatibles avec Junos OS version 21.2R1 et versions ultérieures et commente les déclarations pour traiter les arguments dans les versions antérieures.
Déclaration d’arguments dans le script 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()
Sinon, au lieu d’inclure le arguments dictionnaire dans le script d’exploitation Python, vous pouvez inclure les arguments dans la configuration exactement comme vous le feriez pour les scripts SLAX et XSLT.
Pour afficher les arguments du script op dans l’aide contextuelle de l’interface cli, la commande est la op filename ? suivante.
Affichage des arguments
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
Indiquez les noms et les valeurs de l’argument lorsque vous exécutez le script. Par exemple :
Exécution du 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