Como definir um script de shell para ser originado e não executado

Supondo que você esteja executando o bash, coloque o seguinte código próximo ao início do script que deseja obter, mas não executado:

if [ "${BASH_SOURCE[0]}" -ef "$0" ]
then
    echo "Hey, you should source this script, not execute it!"
    exit 1
fi

Em bash, ${BASH_SOURCE[0]}conterá o nome do arquivo atual que o shell está lendo, independentemente de estar sendo originado ou executado.

Por outro lado, $0é o nome do arquivo atual que está sendo executado.

-eftesta se esses dois arquivos são o mesmo arquivo. Se estiverem, alertamos o usuário e saímos.

Nem são POSIX -ef. BASH_SOURCEEmbora -efseja suportado por ksh, yash, zsh e Dash, BASH_SOURCErequer bash. Emzsh , no entanto, ${BASH_SOURCE[0]}poderia ser substituído por ${(%):-%N}.

Um arquivo não executável pode ser originado, mas não executado, portanto, como primeira linha de defesa, não definir o sinalizador executável deve ser uma boa dica ...

Editar: truque que acabei de descobrir: fazer o shebang ser qualquer executável que não seja um interpretador de shell, /bin/falsefaz com que o script retorne um erro (rc!=0)

#!/bin/false "This script should be sourced in a shell, not executed directly"

Existem vários métodos sugeridos nesta postagem do Stack Overflow , dos quais gostei mais do método baseado em função sugerido por Wirawan Purwanto e mr.spuratic :

A maneira mais robusta, conforme sugerido por Wirawan Purwanto, é verificar FUNCNAME[1] dentro de uma função :

function mycheck() { declare -p FUNCNAME; }
mycheck

Então:

$ bash sourcetest.sh
declare -a FUNCNAME='([0]="mycheck" [1]="main")'
$ . sourcetest.sh
declare -a FUNCNAME='([0]="mycheck" [1]="source")'

Isso equivale a verificar a saída de caller, os valores maine sourcedistinguir o contexto do chamador. O uso FUNCNAME[]evita que você capture e analise callera saída. Você precisa saber ou calcular sua profundidade de chamada local para estar correto. Casos como um script originado de outra função ou script farão com que a matriz (pilha) seja mais profunda. ( FUNCNAMEé uma variável de matriz bash especial, deve ter índices contíguos correspondentes à pilha de chamadas, desde que nunca seja unset).

Então você pode adicionar ao início do script:

function check()
{
    if [[ ${FUNCNAME[-1]} != "source" ]]   # bash 4.2+, use ${FUNCNAME[@]: -1} for older
    then
        printf "Usage: source %s\n" "$0"
        exit 1
    fi
}
check

Quando você origina um script de shell, a linha shebang é ignorada. Ao inserir um shebang inválido, você pode alertar o usuário de que o script foi executado erroneamente:

#!/bin/bash source-this-script
# ...

A mensagem de erro será esta:

/bin/bash: source-this-script: No such file or directory

O nome do argumento (arbitrário) já fornece uma dica forte, mas a mensagem de erro ainda não é 100% clara. Podemos corrigir isso com um script de utilitário source-this-scriptque é colocado em algum lugar no seu PATH:

#!/bin/sh
echo >&2 "This script must be sourced, not executed${1:+: }${1:-!}"
exit 1

Agora, a mensagem de erro será esta:

This script must be sourced, not executed: path/to/script.sh

Comparação com outras abordagens

Em comparação com as outras respostas, essa abordagem requer apenas alterações mínimas em cada script (e ter uma linha shebang ajuda na detecção do tipo de arquivo nos editores e especifica o dialeto do script de shell, portanto, há até benefícios). A desvantagem é uma mensagem de erro pouco clara ou a adição (única) de outro script de shell.

Porém, não impede a invocação explícita via bash path/to/script.sh, (obrigado @muru!).

Supondo que seja apenas inútil, em vez de prejudicial, executar o script, você pode adicionar

return 0 || printf 'Must be sourced, not executed\n' >&2

ao final do roteiro. returnfora de uma função tem um código de saída diferente de zero, a menos que o arquivo esteja sendo originado.

Aqui estão 4 técnicas que eu compilei. Você pode decidir programaticamente o que fazer se o script estiver sendo executado versus originado .

De check_if_sourced_or_executed.sh no meu repositório eRCaGuy_hello_world :

#!/usr/bin/env bash

main() {
    echo "Running main function."

    # put your code here

    echo -e "\nTOTAL TIME TO RUN main func:"
}

# Set the global variable `run` to "true" if the script is being executed and `main` should run, and
# set `run` to "false" otherwise--ex: if the script is being sourced in order to import functions
# from the script, but `main` should NOT run.
run_check() {
    # DEMONSTRATE A FEW DIFFERENT TECHNIQUES

    echo "Technique 1 (can be placed anywhere):"
    echo "  See: https://unix.stackexchange.com/a/424495/114401"
    if [ "${BASH_SOURCE[0]}" -ef "$0" ]; then
        echo "  This script is being EXECUTED."
        run="true"
    else
        echo "  This script is being SOURCED."
    fi


    echo "Technique 2 [MY 2ND FAVORITE] (can be placed anywhere):"
    echo "  Modified from: https://stackoverflow.com/a/29967433/4561887"
    if [ "${BASH_SOURCE[0]}" == "$0" ]; then
        echo "  This script is being EXECUTED."
        run="true"
    else
        echo "  This script is being SOURCED."
    fi

    echo "Technique 3 (requires another line which MUST be **outside** all functions):"
    echo "  Modified from: https://stackoverflow.com/a/28776166/4561887"
    if [ "$script_is_being_executed" == "true" ]; then
        echo "  This script is being EXECUTED."
        run="true"
    else
        echo "  This script is being SOURCED."
    fi


    echo "Technique 4 [MY 1ST FAVORITE] (MUST be **inside** a function):"
    echo "  Modified from: https://stackoverflow.com/a/14706745/4561887"
    echo "  and https://unix.stackexchange.com/a/424552/114401"
    if [ "${FUNCNAME[-1]}" == "main" ]; then
        echo "  This script is being EXECUTED."
        run="true"
    elif [ "${FUNCNAME[-1]}" == "source" ]; then
        echo "  This script is being SOURCED."
    else
        echo "  ERROR: THIS TECHNIQUE IS BROKEN"
    fi

}

# ==================================================================================================
# Main program entry point
# ==================================================================================================

# Only run main function if this file is being executed, NOT sourced.

# For Technique 3. This `return` statement MUST be called at a top-level scope, outside of all
# functions, in order to work! See their detailed explanation here for how it works:
# https://stackoverflow.com/a/28776166/4561887
(return 0 2>/dev/null) && script_is_being_executed="false" || script_is_being_executed="true"

run="false"
run_check
if [ "$run" == "true" ]; then
    time main "$@"
fi

Comandos de execução de teste:

# 1. Execute the script in 2 ways:
#   A. As an executable script
./bash/check_if_sourced_or_executed.sh
#   B. By calling the bash interpreter
bash ./bash/check_if_sourced_or_executed.sh

# 2. Source the script in 2 ways:
#   A. Bash source call
source ./bash/check_if_sourced_or_executed.sh
#   B. (Recommended) POSIX-compliant source call
. ./bash/check_if_sourced_or_executed.sh

Veja também onde descrevi as 4 técnicas no Stack Overflow aqui: https://stackoverflow.com/questions/2683279/how-to-detect-if-a-script-is-being-sourced/70662049#70662049