YorSubs's questions

Esta é uma pergunta infelizmente específica, eu prefiro perguntar algo mais genérico, mas estou perplexo. Eu instalo o Linux Mint mais recente, então vou ao site do NordVPN e sigo o guia para instalar o NordVPN lá, e... nada. Eu sigo o guia da própria empresa. https://support.nordvpn.com/Connectivity/Linux/1325531132/Installing-and-using-NordVPN-on-Debian-Ubuntu-Raspberry-Pi-Elementary-OS-and-Linux-Mint.htm

sh <(curl -sSf https://downloads.nordcdn.com/apps/linux/install.sh)
nordvpn login
nordvpn connect

Ele aceita minhas credenciais de login e diz "Fechar esta janela para retornar ao aplicativo?" então eu faço isso e volto para o console, então ele apenas diz "Você não está logado no NordVPN" se eu tentar executar qualquer comando.

Alguém com experiência relacionada ao Ubuntu/Debian/LinuxMint com NordVPN pode apontar o que estou perdendo ou fazendo errado, por favor?

Eu posso usar statpara criar uma saída ls que mostra os dois formatos de informações de permissão que podem ser úteis:

stat --printf="%A\t%a\t%h\t%U\t%G\t%s\t%.19y\t%n\n" . .*

drwxr-xr-x      755     4       boss    boss    4096    2021-10-29 22:49:12     .
drwxr-xr-x      755     4       boss    boss    4096    2021-10-29 22:49:12     .
drwxr-xr-x      755     36      boss    boss    4096    2021-11-01 11:30:24     ..
-rw-r--r--      644     1       boss    boss    97708   2021-11-01 11:30:16     .custom
-rw-r--r--      644     1       boss    boss    4013    2021-10-11 22:04:04     .custom-dk

No entanto, o espaçamento entre as colunas usa o \tque é bom, mas bastante 'gappy'. Isso me deixou curioso, existe uma maneira genérica de pós-processar quaisquer saídas como essa, de modo que as colunas fiquem no menor denominador comum de lacunas de um espaço, ou seja, existe uma maneira genérica de ajustar o acima para algo como o abaixo usando awkou sedou similar (também estou justificando à direita apenas as colunas numéricas como uma saída 'ideal', se isso for possível)?

drwxr-xr-x 755  4 boss boss  4096 2021-10-29 22:49:12 .
drwxr-xr-x 755  4 boss boss  4096 2021-10-29 22:49:12 .
drwxr-xr-x 755 36 boss boss  4096 2021-11-01 11:30:24 ..
-rw-r--r-- 644  1 boss boss 97708 2021-11-01 11:30:16 .custom
-rw-r--r-- 644  1 boss boss  4013 2021-10-11 22:04:04 .custom-dk

Parece que cleare bash Ctrl- Lsão bem diferentes; clearremove completamente todas as informações anteriores do terminal (para que você não possa rolar para cima) enquanto Ctrl- Lapenas rola a tela para que o cursor fique no topo da página para que você ainda possa rolar para cima e ver as informações anteriores. Eu prefiro o Ctrl- Lsistema. Existe uma maneira de substituir clearpara que ele faça um Ctrl- Lem vez de limpar todas as informações anteriores do terminal? Este não é um grande problema, mas estou apenas me perguntando por curiosidade se existe uma maneira de alias clearapontar para minha funcionalidade preferida Ctrl.L

Como observação lateral, acabei de notar que o PowerShell também tem uma ligação para Ctrl- Le funciona da mesma maneira que Ctrl- Lno bash; parece que os designers do PowerShell tiraram muito do bash, enquanto cmd.exeos consoles não têm essa funcionalidade.

Este site diz que as funções são mais rápidas que os aliases, mas ele corretamente aponta que os aliases são mais fáceis de entender - quando você quer algo muito simples e não precisa considerar passar argumentos, os aliases são convenientes e sensatos. Sendo assim, meu perfil pessoal tem cerca de 1.000 linhas e serve tanto como fonte de funções e ferramentas que utilizo muito, quanto como meio de guardar técnicas que posso consultar e reutilizar para outras tarefas, tanto com pseudônimos e funções lá.

Um problema, porém, é que os aliases têm precedência sobre as funções, e redefinições de aliases e funções podem causar problemas (por exemplo, se eu tiver uma função chamada gge depois no script, por acidente, eu tiver um alias chamado gg- Mas também se uma função é redefinida posteriormente, novamente como uma função, ela substitui a definição anterior). O perfil carrega, mas acabo com problemas. Uma solução poderia ser eliminar todos os aliases e usar apenas funções (alguém faz isso, eu ficaria curioso para saber, porque se eu quiser fazer alias m=manisso é mais intuitivo e sensato que function m() { man $@; }?), mas ainda tenho o problema de redefinições de funções nesse caso.

Existe uma maneira de analisar um script com o objetivo de responder: "para cada declaração de um alias ou função, mostre-me todas as linhas que contêm uma nova declaração (alias ou função) desse item"?

Parece-me (e corrija-me se estiver errado, por favor) que o bash é muito ruim em mensagens de erro que informam corretamente onde está o problema em seu script. Por exemplo, muitas vezes recebo "EOF ruim na linha 953". O que isso realmente significa é que está faltando fina linha 127. Ou, outro clássico é "-bash: linha 60: erro de sintaxe próximo ao token inesperado '('". O que isso realmente significa é que eu redeclarei minha função mything() {}como um alias na linha 739 alias mything=, exceto que, o erro do bash aponta para a linha 60 onde não há nenhum problema real (por isso demorei um pouco para encontrar o culpado na linha 739).

Tentei carregar a ferramenta 'bash debug' de maior sucesso no VS Code e não consegui fazer isso funcionar (pressiono F5 para executar, então aparece uma caixa dizendo "escolha um depurador", então seleciono bash debug e nada acontece) . Eu tentei uma ferramenta online que permite rodar código de forma interativa e diz que pode ajudar na depuração, mas isso também não ajudou. Eu faço um pouco de PowerShell e ele faz um trabalho um pouco melhor em relatar a origem de um problema. Existem maneiras (ferramentas ou ferramentas de análise de script no github ou online que podem verificar um script em busca de problemas como funções e aliases sendo redeclarados com o mesmo nome e outros testes como esse) que nos permitem depurar scripts bash um pouco melhor?

Eu quero pesquisar todas as funções definidas no bash por alguma string de pesquisa. O abaixo é um começo, mas quero então eliminar todos os termos que não são seguidos de espaço em branco na próxima linha (ou seja, eliminar todas as entradas que não foram encontradas $1no corpo dessa função).

fu() { declare -f | grep -e \(\) -e $1; }

por exemplo, esta saída:

...
tt ()
untargz ()
urlfix ()
ver ()
    [ -f /etc/lsb-release ] && RELEASE="$(cat /etc/lsb-release | grep DESCRIPTION | sed 's/^.*=//g' | sed 's/\"//g') ";
vi. ()
vi.su ()
...

reduziria a

...
ver ()
    [ -f /etc/lsb-release ] && RELEASE="$(cat /etc/lsb-release | grep DESCRIPTION | sed 's/^.*=//g' | sed 's/\"//g') ";
...

Uma maneira ainda muito melhor (se possível) seria se todas as funções correspondentes pudessem ser determinadas e exibidas na íntegra.

Eu imagino isso mais ou menos como:

• Colete os nomes das funções com a string de pesquisa em seu corpo (o nome da função é sempre uma única palavra em uma linha antes da correspondência, começando em ^seguido por um espaço e depois a linha terminando com ()$), depois usando command -Vem cada uma dessas names, OR, fazendo um declare -fnovamente, mas desta vez, usando esses nomes e combinando tudo depois deles de {até }(onde {e }estão em linhas únicas por si mesmos em ^- eu sei que grep/awk/sed pode fazer coisas incríveis para aqueles que têm esse conhecimento .

O resultado final estaria em execução fu awke me mostraria a definição de cada função que contém awkno corpo da função.

Eu faço o seguinte para tornar o histórico mais sensato (ou seja, ver quando um comando é executado pode ser bastante crítico na solução de problemas)

shopt -s histappend;   # Append commands to the bash history (~/.bash_history) instead of overwriting it   # https://www.digitalocean.com/community/tutorials/how-to-use-bash-history-commands-and-expansions-on-a-linux-vps
export PROMPT_COMMAND="history -a; history -c; history -r; $PROMPT_COMMAND"   # -a append immediately, then  -c clear history, then -r read history every time a prompt is shown instead of after closing the session.
export HISTTIMEFORMAT="%F %T  " HISTCONTROL=ignorespace:ignoreboth:erasedups HISTSIZE=1000000 HISTFILESIZE=1000000000   # make history very big and show date-time
alias h='history';   # Note: 'h 7' will show last 7 lines

Isso é bom, mas eu quero ser capaz de obter a saída do histórico original se eu precisar. Isso funciona para ho("história original"), mas não posso mais fazer "ho 7"

alias ho="history | awk '{\$2=\$3=\"\"; print \$0}'" # 'history original'

Então eu tentei o seguinte, mas isso falha com erros:

function ho() { history $1 | awk '{\$2=\$3=\"\"; print \$0}'; } # 'history original'

Como posso criar um alias ou função que me permita fazer ho 7e ver apenas as últimas 7 linhas?

No bash, .bashrc(e vários outros scripts) pode carregar na memória na inicialização do shell. Estes podem ter 10 linhas, mas podem ter centenas (se não milhares) de linhas. Cada exportação consumirá uma pequena quantidade de memória, e cada função e cada alias também um pouco de recursos a serem mantidos na memória. Outra consideração é que não podemos apenas olhar para o tamanho dos .bashrcscripts e de outros scripts, pois eles podem ter muitos comentários que não consomem memória.

Eu gostaria de remover todos os scripts de inicialização, iniciar o sistema, esperar alguns minutos para que as coisas se acalmem e, em seguida, obter algum tipo de linha de base, colocar os scripts de inicialização de volta no lugar, reiniciar o sistema e realizar o mesmo exercício para tentar e obter algum tipo de diferencial de recurso/desempenho.

Você pode sugerir quais ferramentas podem ajudar a determinar isso? Eu tenho um conjunto relativamente grande de scripts de inicialização, cerca de 15k com muitas funções e aliases definidos, então estou muito curioso sobre o impacto (se houver, como um sistema moderno com 16 GB de memória e um Core i5 moderno e rápido, o efeito poderia ser insignificante) isso afeta o sistema em termos de recursos consumidos? Mesmo que o impacto dos meus scripts de inicialização seja baixo, eu ainda adoraria poder obter uma linha de base e depois um 'teste de carga' posterior para obter alguma avaliação de como os sistemas lidam com a execução de um determinado conjunto de aplicativos.