Declare e use argumentos de linha de comando em scripts de operação
Os scripts de operação do Junos OS podem aceitar argumentos de linha de comando quando você invoca o script. Você pode incluir declarações no script de operação ou declarações na configuração que permitem que um usuário veja a lista de possíveis argumentos quando solicitam ajuda sensível ao contexto para o script de operação na CLI. O script também deve incluir quaisquer declarações e código necessários para processar esses argumentos. As seções a seguir detalham como definir os argumentos e ajudar a enviar texto e usar os argumentos em um script de operação.
Declarando argumentos de linha de comando de script op
Existem duas maneiras de definir a lista de argumentos de scripts de operação esperados que serão exibidos ao usar ajuda sensível ao contexto na CLI:
-
Inclua declarações no script de operações
-
Inclua declarações na configuração do Junos OS
Os argumentos gerados por script e gerados por configuração têm o mesmo impacto operacional. As seções a seguir explicam como usar os diferentes métodos para definir os argumentos do script de operação e exibi-los na CLI:
- Como definir argumentos no script de operações
- Como definir argumentos na configuração do Junos OS
- Como exibir argumentos na ajuda sensível ao contexto
Como definir argumentos no script de operações
Você pode declarar os argumentos de linha de comando esperados de um script de operação diretamente no script python, SLAX ou XSLT op.
Para declarar argumentos de linha de comando em scripts de operação Python:
- Declare um dicionário global chamado
arguments. - Para cada argumento, defina um par de valor de nome que mapeia o nome do argumento e o texto de ajuda.
Sintaxe Python
# Define arguments dictionary
arguments = {'name1': 'description1', 'name2': 'description2'}
if __name__ == '__main__':
...
Para exibir os argumentos na CLI, os scripts Python devem incluir a if __name__ == '__main__': declaração.
Para declarar argumentos de linha de comando em scripts de operação SLAX ou XSLT:
- Declare uma variável global chamada
arguments. - Para cada argumento, defina um
<argument>elemento. - Dentro de cada
<argument>elemento:- Defina o
<name>elemento com o nome do argumento. - Definir opcionalmente um
<description>elemento que fornece o texto de ajuda para esse argumento.
- Defina o
Sintaxe XSLT
<xsl:variable name="arguments"> <argument> <name>name</name> <description>descriptive-text</description> </argument> </xsl:variable>
Sintaxe SLAX
var $arguments = {
<argument> {
<name> "name";
<description> "descriptive-text";
}
}
Como definir argumentos na configuração do Junos OS
Você pode declarar os argumentos de linha de comando esperados de um script de operação na configuração do Junos OS, como uma alternativa para declarar os argumentos diretamente no script de operação.
Para declarar argumentos de linha de comando na configuração:
- Navegue até a
argumentsdeclaração no nível de[edit system scripts op file filename]hierarquia para o determinado script. - Configure o nome do argumento.
- Configure opcionalmente a
descriptiondeclaração para fornecer o texto de ajuda para o argumento.
Por exemplo:
[edit system scripts op op file file filename] arguments { argument-name { description descriptive-text; } }
Como exibir argumentos na ajuda sensível ao contexto
Depois de declarar argumentos no script de operação ou na configuração, você pode usar a ajuda sensível ao contexto da CLI para listar os argumentos do script de operação. Se você incluir a descrição do argumento opcional, a CLI exibirá o texto de ajuda com o nome do argumento.
user@host> op filename ? Possible completions: argument-name description argument-name description
Você também pode criar um argumento oculto para um script de operação sem incluir a declaração de argumento no script de operação ou na configuração. Você usa o argumento como normalmente faria no script, mas a CLI não exibe o argumento ou ajuda o texto quando você solicita ajuda sensível ao contexto para esse script de operação.
Se você configurar argumentos de linha de comando na configuração do Junos OS e também declarar argumentos diretamente no script de operação, os argumentos que você declara no script ainda estão disponíveis, mas a CLI não os lista quando Possible completions você emite o op filename ? comando. Isso ocorre porque o processo de gerenciamento (mgd) preenche a lista verificando primeiro a configuração em busca de argumentos. O processo de acesso verifica o script em busca de argumentos apenas se nenhum argumento for encontrado na configuração. Assim, se você declarar argumentos na configuração, quaisquer argumentos declarados no script ficam ocultos na CLI.
Para obter mais informações sobre como configurar texto de ajuda para scripts de operação, consulte Configurar texto de ajuda para scripts de operação.
Usando argumentos de linha de comando em scripts de operação
Você executa scripts de operação locais com o op filename comando. Para passar argumentos de linha de comando para o script, inclua cada nome e valor de argumento quando você executa o script.
user@host> op filename argument-name argument-value
Se você especificar um argumento que o script não reconhece, o script ignora o argumento.
As seções a seguir discutem como usar os argumentos de linha de comando que são passados para scripts de operação Python, SLAX e XSLT:
Como usar argumentos em scripts python op
Os scripts op python podem usar bibliotecas padrão de análise de linha de comando para processar e usar argumentos de linha de comando. Por exemplo, você pode usar a biblioteca Python argparse para definir argumentos necessários e opcionais com facilidade, especificar valores padrão e lidar com os argumentos no script.
Para permitir que os usuários usem mais facilmente as bibliotecas Python padrão para analisar argumentos de linha de comando, modificamos a maneira como os argumentos são passados para scripts op Python. A partir do Junos OS Release 21.2R1 e junos OS Evolved Release 21.2R1, quando o dispositivo passa argumentos de linha de comando para um script de operação Python, ele prefixa um único hífen (-) para nomes de argumentos de um único personagem e prefixa dois hífens (--) para nomes de argumentos de vários caracteres. Em versões anteriores, os dispositivos prefixam um único hífen (-) em todos os nomes de argumentos. Você deve garantir que seu script de operação lide adequadamente com os argumentos para sua versão específica.
Os exemplos a seguir usam o argparse módulo para lidar com os argumentos de script. Os exemplos definem o dicionário global arguments , e as chaves do dicionário são usadas para definir os argumentos esperados para o parser. Fornecemos dois scripts de exemplo, que lidam adequadamente com os argumentos nas versões especificadas.
Sintaxe Python (Versão Junos OS 21.2R1 ou 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()
Sintaxe Python (Junos OS Versão 21.1 e anterior)
# 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()
Como usar argumentos em scripts de op SLAX e XSLT
Para usar argumentos de linha de comando em scripts op SLAX ou XSLT, você deve:
- Inclua uma declaração de parâmetro para cada argumento
- Garanta que o nome do parâmetro seja idêntico ao nome que você definiu na
argumentsdeclaração variável no script ou naargumentsdeclaração na configuração do Junos OS.
Sintaxe XSLT
<xsl:param name="name"/>
Sintaxe SLAX
param $name;
O script de operação atribui o valor de cada argumento de script ao parâmetro correspondente, que pode ser mencionado em todo o script.
Exemplo: Declarar argumentos em scripts de operações XSLT
Declare dois argumentos nomeados interface e protocol. Execute o script, especificando a interface ge-0/2/0.0 e o inet protocolo como valores para os argumentos.
Os exemplos a seguir mostram como declarar os argumentos no script XSLT ou na configuração:
Declarando argumentos no 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>
Declarando argumentos na configuração
[edit system scripts op]
file script1 {
arguments {
interface {
description "Name of interface to display";
}
protocol {
description "Protocol to display (inet, inet6)";
}
}
}
Além de declarar os argumentos no script ou na configuração, você também deve declarar os parâmetros correspondentes no script para fazer referência aos argumentos do script e acessar seus valores.
Declarando os parâmetros
<xsl:param name="interface"/> <xsl:param name="protocol"/>
Forneça os nomes e valores dos argumentos quando executar o script. Por exemplo:
Executando o script
user@host> op script1 interface ge-0/2/0.0 protocol inet
Exemplo: declarar e usar argumentos em scripts python op
Declare dois argumentos nomeados interface e p no script de operação Python. Execute o script, especificando a interface ge-0/2/0.0 e o inet protocolo como valores para os argumentos. Selecione as declarações apropriadas de tratamento de argumentos com base em sua versão. O script usa declarações compatíveis com o Junos OS Release 21.2R1 e depois e comenta as declarações para lidar com argumentos em versões mais antigas.
Declarando argumentos no script de operações (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, em vez de incluir o arguments dicionário no script python op, você pode incluir os argumentos na configuração exatamente como você faria para scripts SLAX e XSLT.
Para ver os argumentos do script de operação na ajuda sensível ao contexto da CLI, emita o op filename ? comando.
Exibindo os 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
Forneça os nomes e valores dos argumentos quando executar o script. Por exemplo:
Executando o 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