So erkennen Sie, ob ein Skript bezogen wird

Scheint dies tragbar sein, zwischen Bash und Korn:

[[ $_ != $0 ]] && echo "Script is being sourced" || echo "Script is a subshell"

Eine Zeile vergleichbar zu dieser oder einer Zuordnung wie " pathname="$_" (mit einem späteren test und Aktion) muss auf der ersten Zeile des Skripts oder auf der Zeile nach der shebang (die, wenn verwendet, sollte man zum ksh um für Sie zu arbeiten unter den meisten Umständen).

InformationsquelleAutor der Antwort Dennis Williamson

Nach dem Lesen @DennisWilliamson Antwort, gibt es einige Probleme, siehe unten:

Als diese Frage stand für die ksh und bash, es ist ein weiterer Teil in dieser Antwort bezüglich ksh... siehe unten.

Einfach bash Weg,

[ "$0" = "$BASH_SOURCE" ]

Lassen Sie uns versuchen (on-the-fly, weil bash könnte ;-):

source <(echo $'#!/bin/bash
           [ "$0" = "$BASH_SOURCE" ] && v=own || v=sourced;
           echo "process $$ is $v ($0, $BASH_SOURCE)" ')
process 29301 is sourced (bash, /dev/fd/63)

bash <(echo $'#!/bin/bash
           [ "$0" = "$BASH_SOURCE" ] && v=own || v=sourced;
           echo "process $$ is $v ($0, $BASH_SOURCE)" ')
process 16229 is own (/dev/fd/63, /dev/fd/63)

Benutze ich source statt aus . für die Lesbarkeit (wie . ist ein alias für source):

. <(echo $'#!/bin/bash
           [ "$0" = "$BASH_SOURCE" ] && v=own || v=sourced;
           echo "process $$ is $v ($0, $BASH_SOURCE)" ')
process 29301 is sourced (bash, /dev/fd/63)

Beachten Sie, dass die Prozess-Nummer nicht ändern, während der Prozess bleiben bezogen:

echo $$
29301

Warum nicht verwenden $_ == $0 Vergleich

Dafür viele Fall, ich fange an, schreiben Sie eine wahr Skript:

#!/bin/bash

# As $_ could be used only once, uncomment one of two following lines

#printf '_="%s", 0="%s" and BASH_SOURCE="%s"\n' "$_" "$0" "$BASH_SOURCE"
[[ "$_" != "$0" ]] && DW_PURPOSE=sourced || DW_PURPOSE=subshell

[ "$0" = "$BASH_SOURCE" ] && BASH_KIND_ENV=own || BASH_KIND_ENV=sourced;
echo "proc: $$[ppid:$PPID] is $BASH_KIND_ENV (DW purpose: $DW_PURPOSE)"

Kopieren Sie diese in eine Datei namens testscript:

cat >testscript   
chmod +x testscript

Nun konnten wir testen:

./testscript 
proc: 25758[ppid:24890] is own (DW purpose: subshell)

Ist das ok.

. ./testscript 
proc: 24890[ppid:24885] is sourced (DW purpose: sourced)

source ./testscript 
proc: 24890[ppid:24885] is sourced (DW purpose: sourced)

Ist das ok.

Aber,zum testen ein Skript hinzufügen, bevor -x Flagge:

bash ./testscript 
proc: 25776[ppid:24890] is own (DW purpose: sourced)

Oder verwenden Sie vordefinierte Variablen:

env PATH=/tmp/bintemp:$PATH ./testscript 
proc: 25948[ppid:24890] is own (DW purpose: sourced)

env SOMETHING=PREDEFINED ./testscript 
proc: 25972[ppid:24890] is own (DW purpose: sourced)

Diese nicht mehr funktionieren.

Bewegen Kommentar vom 5. Zeile 6 geben würde, die mehr lesbar Antwort:

./testscript 
_="./testscript", 0="./testscript" and BASH_SOURCE="./testscript"
proc: 26256[ppid:24890] is own

. testscript 
_="_filedir", 0="bash" and BASH_SOURCE="testscript"
proc: 24890[ppid:24885] is sourced

source testscript 
_="_filedir", 0="bash" and BASH_SOURCE="testscript"
proc: 24890[ppid:24885] is sourced

bash testscript 
_="/bin/bash", 0="testscript" and BASH_SOURCE="testscript"
proc: 26317[ppid:24890] is own

env FILE=/dev/null ./testscript 
_="/usr/bin/env", 0="./testscript" and BASH_SOURCE="./testscript"
proc: 26336[ppid:24890] is own

Härter: ksh nun...

Da ich nicht ksh eine Menge, nach einigem Lesen Sie auf der man-Seite, da ist mein versucht:

#!/bin/ksh

set >/tmp/ksh-$$.log

Kopieren Sie diese in ein testfile.ksh:

cat >testfile.ksh
chmod +x testfile.ksh

Als führen Sie es zwei mal:

./testfile.ksh
. ./testfile.ksh

ls -l /tmp/ksh-*.log
-rw-r--r-- 1 user user   2183 avr 11 13:48 /tmp/ksh-9725.log
-rw-r--r-- 1 user user   2140 avr 11 13:48 /tmp/ksh-9781.log

echo $$
9725

und siehe:

diff /tmp/ksh-{9725,9781}.log | grep ^\> # OWN SUBSHELL:
> HISTCMD=0
> PPID=9725
> RANDOM=1626
> SECONDS=0.001
>   lineno=0
> SHLVL=3

diff /tmp/ksh-{9725,9781}.log | grep ^\< # SOURCED:
< COLUMNS=152
< HISTCMD=117
< LINES=47
< PPID=9163
< PS1='$ '
< RANDOM=29667
< SECONDS=23.652
<   level=1
<   lineno=1
< SHLVL=2

Gibt es einige variable herited in einem bezogen laufen, aber nichts wirklich miteinander verwandt sind...

Könnte man sogar prüfen, dass $SECONDS ist in der Nähe 0.000, aber das ist sicher nur Händisch bezogen Fällen...

Sie könnten sogar versuchen, zu prüfen, für was Elternteil:

Legen Sie diese in Ihr testfile.ksh:

ps $PPID

Als:

./testfile.ksh
  PID TTY      STAT   TIME COMMAND
32320 pts/4    Ss     0:00 -ksh

. ./testfile.ksh
  PID TTY      STAT   TIME COMMAND
32319 ?        S      0:00 sshd: user@pts/4

oder ps ho cmd $PPID, aber das funktioniert nur für eine Ebene von subsessions...

Sorry, ich konnte nicht finden, eine zuverlässige Art und Weise zu tun, dass unter ksh.

InformationsquelleAutor der Antwort F. Hauri

Den BASH_SOURCE[] Antwort (bash-3.0 und höher) scheint die einfachste, obwohl BASH_SOURCE[] ist nicht dokumentiert zu arbeiten, die außerhalb einer Funktion Körper (es aktuell passiert, zu arbeiten, sich im Streit mit der man-Seite).

Die robuste Art und Weise, wie vorgeschlagen von Wirawan Purwanto, ist zu überprüfen FUNCNAME[1] innerhalb einer Funktion:

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

Dann:

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

Dies ist das äquivalent zu dem Sie die Ausgabe von caller die Werte main und source unterscheiden, die der Anrufer Kontext. Mit FUNCNAME[] speichert Sie erfassen und analysieren caller Ausgabe. Sie müssen wissen oder berechnen Sie Ihren lokalen Aufruf-Tiefe korrekt zu sein, obwohl. Fälle, wie ein Skript bezogen werden von innerhalb einer anderen Funktion oder ein Skript verursacht array (stack) werden tiefer. (FUNCNAME ist eine spezielle bash-array-Variablen es sollten zusammenhängende Indizes entsprechend dem call-stack, so lange, wie es noch nie unset.)

function issourced() {
    [[ ${FUNCNAME[@]: -1} == "source" ]]
}

(In der bash-4.2 und höher können Sie die einfachere form ${FUNCNAME[-1]} statt für das Letzte Element im array. Verbessert und vereinfacht Dank Dennis Williamson ' s Kommentar unten).

Aber dein problem wie gesagt ist, "ich habe ein Skript, wo ich nicht wollen, es zu nennen 'exit' wenn es bezogen werden". Die gemeinsame bash idiom für diese situation ist:

return 2>/dev/null || exit

Wenn das Skript bezogen werden, dann return beenden wird das ursprüngliche Skript und an den Aufrufer zurückgeben.

Wenn das Skript ausgeführt wird, dann return wird ein Fehler zurückgegeben (umgeleitet), und exit wird das Skript beendet als normal. Beide return und exit können einen exit-code, falls erforderlich.

Leider funktioniert das nicht in ksh (zumindest nicht in der AT&T abgeleitete version, die ich hier habe), es behandelt return als äquivalent zu exit wenn aufgerufen, außerhalb einer Funktion oder dot-Source-Skript.

Aktualisiert: Was Sie kann tun in der zeitgenössischen Versionen von ksh ist zu prüfen, die spezielle variable .sh.level dem Aufruf der Funktion Tiefe. Für ein Skript aufgerufen wird diese zunächst gelöscht werden, für ein dot-sourced script auf 1 gesetzt werden.

function issourced {
    [[ ${.sh.level} -eq 2 ]]
}

issourced && echo this script is sourced

Dies ist nicht ganz so robust sind wie die bash-version, die Sie aufrufen müssen issourced() in der Datei, die Sie testen aus, auf der obersten Ebene oder an eine bekannte Funktion der Tiefe.

(Sie könnten auch interessiert sein in dieser code auf github verwendet eine ksh Disziplin Funktion und einige debug-trap Tricks zu emulieren, die bash FUNCNAME array.)

Die kanonische Antwort hier: http://mywiki.wooledge.org/BashFAQ/109 bietet auch $- als ein weiteres Indiz (aber unvollkommen) von der shell-Zustand.

Hinweise:

• es ist möglich, erstellen von bash-Funktionen mit dem Namen "main" und "Quelle" (überschreiben der builtin), diese Namen erscheinen in FUNCNAME[] aber solange nur das Letzte Element in diesem array ist getestet, es ist keine Zweideutigkeit.
• Ich nicht haben eine gute Antwort für pdksh. Die nächste Sache, die ich finden kann bezieht sich nur auf pdksh, wobei jede Beschaffung ein script öffnet eine neue Datei-Deskriptor (beginnend mit 10 für das original-Skript). Fast sicher nicht etwas, was Sie wollen zu verlassen...

InformationsquelleAutor der Antwort mr.spuratic

Gebe ich ein BASH-spezifische Antwort. Korn-shell, sorry. Angenommen, Ihr Skript name ist include2.sh ; dann machen Sie eine Funktion innen die include2.sh genannt am_I_sourced. Hier ist meine demo-version von include2.sh:

am_I_sourced()
{
  if [ "${FUNCNAME[1]}" = source ]; then
    if [ "$1" = -v ]; then
      echo "I am being sourced, this filename is ${BASH_SOURCE[0]} and my caller script/shell name was $0"
    fi
    return 0
  else
    if [ "$1" = -v ]; then
      echo "I am not being sourced, my script/shell name was $0"
    fi
    return 1
  fi
}

if am_I_sourced -v; then
  echo "Do something with sourced script"
else
  echo "Do something with executed script"
fi

Nun versuchen Sie zu ausführen es in vielerlei Hinsicht:

~/toys/bash $ chmod a+x include2.sh

~/toys/bash $ ./include2.sh 
I am not being sourced, my script/shell name was ./include2.sh
Do something with executed script

~/toys/bash $ bash ./include2.sh 
I am not being sourced, my script/shell name was ./include2.sh
Do something with executed script

~/toys/bash $ . include2.sh
I am being sourced, this filename is include2.sh and my caller script/shell name was bash
Do something with sourced script

Damit dies funktioniert, ohne Ausnahme, und es ist nicht mit der spröden $_ Zeug. Dieser trick nutzt die BASH - introspection facility, D. H. built-in Variablen FUNCNAME und BASH_SOURCE; siehe deren Dokumentation in der bash-Manpage.

Nur zwei caveat:

1) der Aufruf zu am_I_called muss stattfinden in das ursprüngliche Skript, aber nicht innerhalb jede Funktion, damit ${FUNCNAME[1]} gibt etwas anderes. Ja...Sie haben könnten, überprüft ${FUNCNAME[2]} -- aber Sie nur machen Ihr das Leben schwer.

2) Funktion am_I_called muss Wohnsitz in das ursprüngliche Skript, wenn Sie herausfinden möchten, was den Namen der Datei enthalten.

InformationsquelleAutor der Antwort Wirawan Purwanto

Diese Werke später im Skript und muss nicht davon abhängen, _ - variable:

## Check to make sure it is not sourced:
Prog=myscript.sh
if [ $(basename $0) = $Prog ]; then
   exit 1  # not sourced
fi

oder

[ $(basename $0) = $Prog ] && exit

InformationsquelleAutor der Antwort jim mcnamara

FWIW, nach der Lektüre all die anderen Antworten, kam ich auf folgende Lösung für mich:

Dies funktioniert für alle Skripte, die start mit #!/bin/bash aber kann bezogen werden von verschiedenen Muscheln als gut.

#!/bin/bash

# Function definitions (API) and shell variables (constants) go here

main()
{
# The script's execution part goes here
}

unset BASH_SOURCE 2>/dev/null
test ".$0" != ".$BASH_SOURCE" || main "$@"

Dieses Skript Rezept hat folgende Eigenschaften:

• Wenn ausgeführt durch bash, main genannt wird.
• Wenn sourced von bash, main wird nur aufgerufen, wenn der aufrufende Skript, das zufällig den gleichen Namen. (Zum Beispiel, wenn es Quellen selbst.)
• Wenn sourced durch eine andere shell als bash, main ist nicht genannt.
• , Wenn die Ausführung durch eine andere shell als bash, main ist nicht genannt.

• Wenn bewertet von bash mit eval (eval "`cat script`" alle Anführungszeichen sind wichtig!) der kommt nicht direkt von der Kommandozeile, diese Anrufe main. Für alle anderen Varianten von eval, main ist nicht genannt.

• Wenn main ist nicht genannt, es zurück true ($?=0).

• Und es sich nicht auf undokumentierte Verhalten was ändern könnte.

Somit, mit Ausnahme für einige unwahrscheinlich Ecke Fällen main wird nur aufgerufen, wenn das Skript ausgeführt wird, den üblichen Weg. Normalerweise ist dies, was Sie wollen, vor allem, weil Sie nicht Komplex, schwer zu verstehen code.

Als BASH_SOURCE kann nicht gelöscht werden in bash, aber in allen anderen shells, diese auch ins edge-Fall, wo BASH_SOURCE passiert, festgelegt werden, um $0.

Beachten Sie, dass es ist sehr ähnlich wie die Python-code:

if __name__ == '__main__': main()

Welche auch verhindert das aufrufen von main abgesehen von einigen Sonderfällen, wie
Sie können importieren/laden Sie das Skript und durchzusetzen, dass __name__='__main__'

, Warum ich denke, das ist eine gute Allgemeine Methode zur Lösung der Herausforderung

Wenn Sie etwas haben, die bezogen werden können, die von mehreren Schalen, es muss kompatibel sein. Allerdings (Lesen der anderen Antworten), , da es keine portable Möglichkeit zum erkennen der sourceing, müssen Sie die Regeln ändern.

Durch das erzwingen, dass das Skript ausgeführt werden muss /bin/bash Sie genau dies tun.

Diese löst alle Fälle, aber folgende in welchem Fall das Skript nicht ausgeführt werden kann direkt:

• /bin/bash ist nicht installiert oder disfunctional (ich. E. in einer boot-Umgebung)
• Wenn Sie pipe es zu einer nicht-bash-shell wie in curl https://example.com/script | $SHELL wo $SHELL ist nicht bash

Aber ich kann mir nicht denken, über alle realen Grund, wo Sie Sie brauchen, und auch die Fähigkeit, eine Quelle, die genau das gleiche Skript parallel! In der Regel können Sie wickeln Sie es, so dass das Skript immer bezogen. Führen Sie dann die main von hand. So:

• sh -c '. script && main'
• echo 'eval "`curl https://example.com/script`" && main' | $SHELL

Wichtig:

Letztere läuft main zweimal, wenn $SHELL läuft bash und die Linie wird nicht ausgeführt von der Kommandozeile ausgeführt werden. (Aber ich kann mir wirklich nicht aus irgendeinem Grund denken, warum sollten Sie jemals verwenden Sie diese in einem Skript, außer für Narren Sie den code mit Absicht.)

Hinweis

Diese Antwort wäre nicht möglich gewesen ohne die Hilfe von allen die anderen Antworten! Auch noch die falschen lieben, die mir dieses posting.

InformationsquelleAutor der Antwort Tino

Ich glaube nicht, dass es eine portable Möglichkeit, dies zu tun in beiden ksh und bash. In der bash könnte man erkennen, es mit caller Ausgang, aber ich glaube nicht, dass es existiert, entspricht in der ksh.

InformationsquelleAutor der Antwort Michal Čihař

Direkt auf den Punkt: müssen Sie bewerten, wenn die variable "$0" gleich den Namen Ihrer Shell.

Wie diese:

#!/bin/bash

echo "First Parameter: $0"
echo
if [[ "$0" == "bash" ]] ; then
    echo "The script was sourced."
else
    echo "The script WAS NOT sourced."
fi

, Die über die SHELL:

$ bash check_source.sh 
First Parameter: check_source.sh

The script WAS NOT sourced.

Über QUELLE:

$ source check_source.sh
First Parameter: bash

The script was sourced.

Es ist ziemlich schwierig, eine 100% portable Weg, erkennen, wenn ein Skript Quelle wurde oder nicht.

Bezüglich meiner Erfahrung (7 Jahre mit Shellscripting), der einzige sichere Weg (nicht abhängig von Umgebungsvariablen mit PIDs und so weiter, das ist nicht sicher, aufgrund der Tatsache, dass es etwas VARIABLE), man soll:

• erweitern die Möglichkeiten aus Ihr, wenn
• mit switch/case, wenn Sie wollen.

Beide Optionen werden nicht automatisch skaliert, aber es ist der sicherere Weg.

Zum Beispiel:

, wenn Sie Quellcode ein Skript über eine SSH-session, wird der Wert zurückgegeben, der durch die variable "$0" (bei Verwendung Quelle), ist -bash.

#!/bin/bash

echo "First Parameter: $0"
echo
if [[ "$0" == "bash" || "$0" == "-bash" ]] ; then
    echo "The script was sourced."
else
    echo "The script WAS NOT sourced."
fi

ODER

#!/bin/bash

echo "First Parameter: $0"
echo
if [[ "$0" == "bash" ]] ; then
    echo "The script was sourced."
elif [[ "$0" == "-bash" ]] ; then
    echo "The script was sourced via SSH session."
else
    echo "The script WAS NOT sourced."
fi

InformationsquelleAutor der Antwort ivanleoncz