Descubra quais scripts estão sendo executados pelo bash na inicialização

Question

Depois de iniciar um terminal bash, notei que a variável PATH contém entradas duplicadas. Meu terminal inicia um login shell , então ~/.bash_profile é originado, seguido por ~/.profile e ~/.bashrc . Apenas em ~/.profile eu crio as entradas de caminhos duplicadas.

Para ser pedante, essa é a ordem na qual os arquivos que DEVEM ser originados estão sendo originados:

Sourced /etc/profile
Sourced /etc/bash.bashrc
Sourced .bash_profile
Sourced .profile
Sourced .bashrc

Antes que alguém marque isso como uma duplicata de "variável PATH contém duplicatas", continue lendo.

No começo eu pensei que isso tinha a ver com ~/.profile sendo originado duas vezes, então eu mandei o arquivo gravar em um arquivo de log sempre que ele foi originado, e surpreendentemente ele registrou apenas uma entrada, o que me diz que uma vez. Ainda mais surpreendente é o fato de que quando eu comento as entradas que estavam em ~/.profile , as entradas ainda aparecem na variável PATH . Isso me levou a três conclusões, uma das quais foi rapidamente descartada:

1. Bash ignora os comentários válidos do bash e ainda executa o código comentado
2. Existe um script que lê o ~/.profile e ignora qualquer código que imprima uma saída (o arquivo de log, por exemplo)
3. Existe outra cópia do meu ~/.profile que está sendo originado em outro lugar

O primeiro, eu rapidamente concluí não ser o caso devido a alguns testes rápidos. A segunda e terceira opções são onde eu preciso de ajuda.

Como faço para reunir um log de scripts que são executados quando meu terminal é inicializado? Eu usei echo nos arquivos que eu verifiquei para saber se eles são originados por bash, mas preciso para encontrar um método conclusivo que traça a execução até o ponto em que o terminal está pronto para eu começar a digitar nele.

Se o acima não for possível, alguém pode sugerir onde mais posso ver quais scripts estão sendo executados .

Referência futura

Este é o script que agora uso para adicionar ao meu caminho:

function add_to_path() {
    for path in ${2//:/ }; do
        if ! [[ "${!1}" =~ "${path%/}" ]]; then # ignore last /
            new_path="$path:${!1#:}"
            export "$1"="${new_path%:}" # remove trailing :
        fi
    done
}

Eu uso assim:

add_to_path 'PATH' "/some/path/bin"

O script verifica se o caminho já existe na variável antes de o preceder.

Para usuários zsh, você pode usar este equivalente:

function add_to_path() {
    for p in ${(s.:.)2}; do
        if [[ ! "${(P)1}" =~ "${p%/}" ]]; then
            new_path="$p:${(P)1#:}"
            export "$1"="${new_path%:}"
        fi
    done
}

Editar 28/8/2018

Mais uma coisa que achei que poderia fazer com esse script é também corrigir o caminho. Então, no começo do meu arquivo .bashrc , eu faço algo assim:

_temp_path="$PATH"
PATH='/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin'
add_to_path 'PATH' "$_temp_path"
unset _temp_path

É com você que o PATH deve começar. Examine PATH primeiro para decidir.

    

Answer 1

Se o seu sistema tiver strace , você poderá listar os arquivos abertos pelo shell, por exemplo, usando

echo exit | strace bash -li |& less | grep '^open'

( -li significa shell de login interativo; use apenas -i para um shell interativo de não-login.)

Isso mostrará uma lista de arquivos que o shell abriu ou tentou abrir. No meu sistema, eles são os seguintes:

1. /etc/profile
2. /etc/profile.d/* (vários scripts em /etc/profile.d/ )
3. /home/<username>/.bash_profile (isso falha, não tenho esse arquivo)
4. /home/<username>/.bash_login (isso falha, não tenho esse arquivo)
5. /home/<username>/.profile
6. /home/<username>/.bashrc
7. /home/<username>/.bash_history (histórico de linhas de comando; este não é um script)
8. /usr/share/bash-completion/bash_completion
9. /etc/bash_completion.d/* (vários scripts que fornecem funcionalidade de preenchimento automático)
10. /etc/inputrc (define ligações de teclas; isso não é um script)

Use man strace para mais informações.