Wie erkenne ich das Betriebssystem anhand eines Bash-Skripts?

Ich möchte meine .bashrcund .bash_loginDateien in der Versionskontrolle behalten, damit ich sie zwischen allen von mir verwendeten Computern verwenden kann. Das Problem ist, dass ich einige betriebssystemspezifische Aliase habe und daher nach einer Möglichkeit gesucht habe, festzustellen, ob das Skript unter Mac OS X, Linux oder Cygwin ausgeführt wird .

Was ist der richtige Weg, um das Betriebssystem in einem Bash- Skript zu erkennen?

Ich denke, das Folgende sollte funktionieren. Ich bin mir win32allerdings nicht sicher .

if [[ "$OSTYPE" == "linux-gnu"* ]]; then
        # ...
elif [[ "$OSTYPE" == "darwin"* ]]; then
        # Mac OSX
elif [[ "$OSTYPE" == "cygwin" ]]; then
        # POSIX compatibility layer and Linux environment emulation for Windows
elif [[ "$OSTYPE" == "msys" ]]; then
        # Lightweight shell and GNU utilities compiled for Windows (part of MinGW)
elif [[ "$OSTYPE" == "win32" ]]; then
        # I'm not sure this can happen.
elif [[ "$OSTYPE" == "freebsd"* ]]; then
        # ...
else
        # Unknown.
fi

Für meine .bashrc verwende ich den folgenden Code:

platform='unknown'
unamestr=`uname`
if [[ "$unamestr" == 'Linux' ]]; then
   platform='linux'
elif [[ "$unamestr" == 'FreeBSD' ]]; then
   platform='freebsd'
fi

Dann mache ich etwas wie:

if [[ $platform == 'linux' ]]; then
   alias ls='ls --color=auto'
elif [[ $platform == 'freebsd' ]]; then
   alias ls='ls -G'
fi

Es ist hässlich, aber es funktioniert. Sie können caseanstelle von verwenden, ifwenn Sie es vorziehen.

Die Bash-Manpage besagt, dass die Variable OSTYPE den Namen des Betriebssystems speichert:

OSTYPEWird automatisch auf eine Zeichenfolge festgelegt, die das Betriebssystem beschreibt, auf dem Bash ausgeführt wird. Die Standardeinstellung ist systemabhängig.

Es ist linux-gnuhier eingestellt.

$OSTYPE

Sie können einfach eine vordefinierte $OSTYPEVariable verwenden, z.

case "$OSTYPE" in
  solaris*) echo "SOLARIS" ;;
  darwin*)  echo "OSX" ;; 
  linux*)   echo "LINUX" ;;
  bsd*)     echo "BSD" ;;
  msys*)    echo "WINDOWS" ;;
  *)        echo "unknown: $OSTYPE" ;;
esac

Es wird jedoch von den älteren Muscheln (wie der Bourne-Muschel ) nicht erkannt .

uname

Eine andere Methode besteht darin, eine Plattform basierend auf zu erkennen uname Befehl .

Siehe das folgende Skript (bereit, in .bashrc aufgenommen zu werden):

# Detect the platform (similar to $OSTYPE)
OS="`uname`"
case $OS in
  'Linux')
    OS='Linux'
    alias ls='ls --color=auto'
    ;;
  'FreeBSD')
    OS='FreeBSD'
    alias ls='ls -G'
    ;;
  'WindowsNT')
    OS='Windows'
    ;;
  'Darwin') 
    OS='Mac'
    ;;
  'SunOS')
    OS='Solaris'
    ;;
  'AIX') ;;
  *) ;;
esac

Ein praktisches Beispiel finden Sie in meinem.bashrc .

Hier ist eine ähnliche Version, die auf Travis CI verwendet wird :

case $(uname | tr '[:upper:]' '[:lower:]') in
  linux*)
    export TRAVIS_OS_NAME=linux
    ;;
  darwin*)
    export TRAVIS_OS_NAME=osx
    ;;
  msys*)
    export TRAVIS_OS_NAME=windows
    ;;
  *)
    export TRAVIS_OS_NAME=notset
    ;;
esac

Das Erkennen von Betriebssystem und CPU-Typ ist nicht so einfach portabel . Ich habe ein shSkript mit ungefähr 100 Zeilen, das auf einer Vielzahl von Unix-Plattformen funktioniert: jedes System, das ich seit 1988 verwende.

Die Schlüsselelemente sind

• uname -pist ein Prozessortyp , befindet sich jedoch normalerweise unknownauf modernen Unix-Plattformen.

• uname -m gibt auf einigen Unix-Systemen den "Namen der Maschinenhardware" an.

• /bin/arch, falls vorhanden, gibt normalerweise den Prozessortyp an.

• uname Ohne Argumente wird das Betriebssystem benannt.

Schließlich müssen Sie über die Unterschiede zwischen Plattformen nachdenken und darüber, wie gut Sie sie machen möchten. Zum Beispiel, nur die Dinge einfach zu halten, behandeln ich i386durch i686jede „ Pentium*“ und alle „ AMD*Athlon*“ alle alsx86 .

My ~/.profileführt beim Start ein Skript aus, das eine Variable auf eine Zeichenfolge setzt, die die Kombination von CPU und Betriebssystem angibt. Ich habe plattformspezifische bin, man, lib, und includeVerzeichnisse , die auf das gesetzt bekommen basiert. Dann habe ich eine Schiffsladung Umgebungsvariablen gesetzt. So kann beispielsweise ein Shell-Skript zum Neuformatieren von E-Mails z.$LIB/mailfmt eine plattformspezifische ausführbare Binärdatei.

Wenn Sie schneiden Ecken wollen , uname -mund Ebene unamewird Ihnen sagen , was Sie auf vielen Plattformen wissen wollen. Fügen Sie andere Dinge hinzu, wenn Sie es brauchen. (Und verwenden case, nicht verschachtelt if!)

Ich empfehle, diesen vollständigen Bash-Code zu verwenden

lowercase(){
    echo "$1" | sed "y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/"
}

OS=`lowercase \`uname\``
KERNEL=`uname -r`
MACH=`uname -m`

if [ "{$OS}" == "windowsnt" ]; then
    OS=windows
elif [ "{$OS}" == "darwin" ]; then
    OS=mac
else
    OS=`uname`
    if [ "${OS}" = "SunOS" ] ; then
        OS=Solaris
        ARCH=`uname -p`
        OSSTR="${OS} ${REV}(${ARCH} `uname -v`)"
    elif [ "${OS}" = "AIX" ] ; then
        OSSTR="${OS} `oslevel` (`oslevel -r`)"
    elif [ "${OS}" = "Linux" ] ; then
        if [ -f /etc/redhat-release ] ; then
            DistroBasedOn='RedHat'
            DIST=`cat /etc/redhat-release |sed s/\ release.*//`
            PSUEDONAME=`cat /etc/redhat-release | sed s/.*\(// | sed s/\)//`
            REV=`cat /etc/redhat-release | sed s/.*release\ // | sed s/\ .*//`
        elif [ -f /etc/SuSE-release ] ; then
            DistroBasedOn='SuSe'
            PSUEDONAME=`cat /etc/SuSE-release | tr "\n" ' '| sed s/VERSION.*//`
            REV=`cat /etc/SuSE-release | tr "\n" ' ' | sed s/.*=\ //`
        elif [ -f /etc/mandrake-release ] ; then
            DistroBasedOn='Mandrake'
            PSUEDONAME=`cat /etc/mandrake-release | sed s/.*\(// | sed s/\)//`
            REV=`cat /etc/mandrake-release | sed s/.*release\ // | sed s/\ .*//`
        elif [ -f /etc/debian_version ] ; then
            DistroBasedOn='Debian'
            DIST=`cat /etc/lsb-release | grep '^DISTRIB_ID' | awk -F=  '{ print $2 }'`
            PSUEDONAME=`cat /etc/lsb-release | grep '^DISTRIB_CODENAME' | awk -F=  '{ print $2 }'`
            REV=`cat /etc/lsb-release | grep '^DISTRIB_RELEASE' | awk -F=  '{ print $2 }'`
        fi
        if [ -f /etc/UnitedLinux-release ] ; then
            DIST="${DIST}[`cat /etc/UnitedLinux-release | tr "\n" ' ' | sed s/VERSION.*//`]"
        fi
        OS=`lowercase $OS`
        DistroBasedOn=`lowercase $DistroBasedOn`
        readonly OS
        readonly DIST
        readonly DistroBasedOn
        readonly PSUEDONAME
        readonly REV
        readonly KERNEL
        readonly MACH
    fi

fi

Weitere Beispiele hier: https://github.com/coto/server-easy-install/blob/master/lib/core.sh

Verwenden Sie in bash $OSTYPEund $HOSTTYPE, wie dokumentiert; das ist was ich mache. Wenn dies nicht ausreicht und gerade unameoder uname -a(oder andere geeignete Optionen) nicht genügend Informationen liefern, gibt es immer das Skript config.guess aus dem GNU-Projekt, das genau für diesen Zweck erstellt wurde.

Ich würde vorschlagen, einige dieser Antworten zu vermeiden. Vergessen Sie nicht, dass Sie andere Formen des Zeichenfolgenvergleichs auswählen können, um die meisten Variationen oder den angebotenen hässlichen Code zu beseitigen.

Eine solche Lösung wäre eine einfache Überprüfung, wie zum Beispiel:

if [[ "$OSTYPE" =~ ^darwin ]]; then

Dies hat den zusätzlichen Vorteil, dass jede Version von Darwin trotz des Versionssuffixes übereinstimmt. Dies funktioniert auch für alle Variationen vonLinux man erwarten kann.

Sie können einige zusätzliche Beispiele in meinen Punktedateien hier sehen

Versuchen Sie es mit "uname". Zum Beispiel unter Linux: "uname -a".

Laut der Handbuchseite entspricht uname SVr4 und POSIX, daher sollte es unter Mac OS X und Cygwin verfügbar sein , aber das kann ich nicht bestätigen.

Übrigens: $ OSTYPE ist auch linux-gnuhier eingestellt :)

Ich schrieb diese Zucker in meine .bashrc:

if_os () { [[ $OSTYPE == *$1* ]]; }
if_nix () { 
    case "$OSTYPE" in
        *linux*|*hurd*|*msys*|*cygwin*|*sua*|*interix*) sys="gnu";;
        *bsd*|*darwin*) sys="bsd";;
        *sunos*|*solaris*|*indiana*|*illumos*|*smartos*) sys="sun";;
    esac
    [[ "${sys}" == "$1" ]];
}

So kann ich Sachen machen wie:

if_nix gnu && alias ls='ls --color=auto' && export LS_COLORS="..."
if_nix bsd && export CLICOLORS=on && export LSCOLORS="..."
if_os linux && alias psg="ps -FA | grep" #alternative to pgrep
if_nix bsd && alias psg="ps -alwx | grep -i" #alternative to pgrep
if_os darwin && alias finder="open -R"

uname

oder

uname -a

Wenn Sie weitere Informationen wünschen

Ich habe eine persönliche Bash-Bibliothek und ein Scripting-Framework geschrieben , das GNU shtool verwendet , um eine ziemlich genaue Plattformerkennung .

GNU shtool ist ein sehr portabler Satz von Skripten, der unter anderem den Befehl 'shtool platform' enthält. Hier ist die Ausgabe von:

shtool platform -v -F "%sc (%ac) %st (%at) %sp (%ap)"

auf einigen verschiedenen Maschinen:

Mac OS X Leopard: 
    4.4BSD/Mach3.0 (iX86) Apple Darwin 9.6.0 (i386) Apple Mac OS X 10.5.6 (iX86)

Ubuntu Jaunty server:
    LSB (iX86) GNU/Linux 2.9/2.6 (i686) Ubuntu 9.04 (iX86)

Debian Lenny:
    LSB (iX86) GNU/Linux 2.7/2.6 (i686) Debian GNU/Linux 5.0 (iX86)

Dies führt zu ziemlich zufriedenstellenden Ergebnissen, wie Sie sehen können. GNU shtool ist etwas langsam, daher speichere und aktualisiere ich die Plattformidentifikation tatsächlich in einer Datei auf dem System, das meine Skripte aufrufen. Es ist mein Rahmen, so dass es für mich funktioniert, aber Ihr Kilometerstand kann variieren.

Jetzt müssen Sie einen Weg finden, shtool mit Ihren Skripten zu verpacken, aber es ist keine schwierige Übung. Sie können auch jederzeit auf die Ausgabe ohne Namen zurückgreifen.

BEARBEITEN:

Ich habe den Beitrag von Teddy über config.guess(irgendwie) verpasst . Dies sind sehr ähnliche Skripte, aber nicht die gleichen. Ich persönlich benutze shtool auch für andere Zwecke und es hat für mich ganz gut funktioniert.

Sie können Folgendes verwenden:

OS=$(uname -s)

Dann können Sie die Betriebssystemvariable in Ihrem Skript verwenden.

Im Folgenden finden Sie einen Ansatz zum Erkennen von Debian- und RedHat-basierten Linux-Betriebssystemen unter Verwendung von / etc / lsb-release und / etc / os-release (abhängig von der verwendeten Linux -Version ) und zum Ausführen einer einfachen darauf basierenden Aktion.

#!/bin/bash
set -e

YUM_PACKAGE_NAME="python python-devl python-pip openssl-devel"
DEB_PACKAGE_NAME="python2.7 python-dev python-pip libssl-dev"

 if cat /etc/*release | grep ^NAME | grep CentOS; then
    echo "==============================================="
    echo "Installing packages $YUM_PACKAGE_NAME on CentOS"
    echo "==============================================="
    yum install -y $YUM_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Red; then
    echo "==============================================="
    echo "Installing packages $YUM_PACKAGE_NAME on RedHat"
    echo "==============================================="
    yum install -y $YUM_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Fedora; then
    echo "================================================"
    echo "Installing packages $YUM_PACKAGE_NAME on Fedorea"
    echo "================================================"
    yum install -y $YUM_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Ubuntu; then
    echo "==============================================="
    echo "Installing packages $DEB_PACKAGE_NAME on Ubuntu"
    echo "==============================================="
    apt-get update
    apt-get install -y $DEB_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Debian ; then
    echo "==============================================="
    echo "Installing packages $DEB_PACKAGE_NAME on Debian"
    echo "==============================================="
    apt-get update
    apt-get install -y $DEB_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Mint ; then
    echo "============================================="
    echo "Installing packages $DEB_PACKAGE_NAME on Mint"
    echo "============================================="
    apt-get update
    apt-get install -y $DEB_PACKAGE_NAME
 elif cat /etc/*release | grep ^NAME | grep Knoppix ; then
    echo "================================================="
    echo "Installing packages $DEB_PACKAGE_NAME on Kanoppix"
    echo "================================================="
    apt-get update
    apt-get install -y $DEB_PACKAGE_NAME
 else
    echo "OS NOT DETECTED, couldn't install package $PACKAGE"
    exit 1;
 fi

exit 0

Ausgabebeispiel für Ubuntu Linux:

delivery@delivery-E5450$ sudo sh detect_os.sh
[sudo] password for delivery: 
NAME="Ubuntu"
===============================================
Installing packages python2.7 python-dev python-pip libssl-dev on Ubuntu
===============================================
Ign http://dl.google.com stable InRelease
Get:1 http://dl.google.com stable Release.gpg [916 B]                          
Get:2 http://dl.google.com stable Release [1.189 B] 
...            

Dies sollte in allen Distributionen sicher sein.

$ cat /etc/*release

Dies erzeugt so etwas.

     DISTRIB_ID=LinuxMint
     DISTRIB_RELEASE=17
     DISTRIB_CODENAME=qiana
     DISTRIB_DESCRIPTION="Linux Mint 17 Qiana"
     NAME="Ubuntu"
     VERSION="14.04.1 LTS, Trusty Tahr"
     ID=ubuntu
     ID_LIKE=debian
     PRETTY_NAME="Ubuntu 14.04.1 LTS"
     VERSION_ID="14.04"
     HOME_URL="http://www.ubuntu.com/"
     SUPPORT_URL="http://help.ubuntu.com/"
     BUG_REPORT_URL="http://bugs.launchpad.net/ubuntu/"

Extrahieren / Zuweisen von Variablen nach Ihren Wünschen

Hinweis: Bei einigen Setups. Dies kann auch zu Fehlern führen, die Sie ignorieren können.

     cat: /etc/upstream-release: Is a directory

Versuche dies:

DISTRO=$(cat /etc/*-release | grep -w NAME | cut -d= -f2 | tr -d '"')
echo "Determined platform: $DISTRO"

Sie können die folgende if-Klausel verwenden und nach Bedarf erweitern:

if [ "${OSTYPE//[0-9.]/}" == "darwin" ]
then
    aminute_ago="-v-1M"
elif  [ "${OSTYPE//[0-9.]/}" == "linux-gnu" ]
then
    aminute_ago="-d \"1 minute ago\""
fi

Ich habe die oben genannten Meldungen in einigen Linux-Distributionen ausprobiert und festgestellt, dass Folgendes für mich am besten funktioniert. Es ist eine kurze, präzise Wortantwort, die auch für Bash unter Windows funktioniert.

OS=$(cat /etc/*release | grep ^NAME | tr -d 'NAME="') #$ echo $OS # Ubuntu

Ich neige dazu, meine .bashrc- und .bash_alias-Dateien auf einer Dateifreigabe zu belassen, auf die alle Plattformen zugreifen können. So überwinde ich das Problem in meinen .bash_alias:

if [[ -f (name of share)/.bash_alias_$(uname) ]]; then
    . (name of share)/.bash_alias_$(uname)
fi

Und ich habe zum Beispiel eine .bash_alias_Linux mit:

alias ls='ls --color=auto'

Auf diese Weise halte ich plattformspezifischen und portablen Code getrennt. Sie können dasselbe für .bashrc tun

Dies überprüft eine Reihe von knownDateien auf Identifikation, wenn die Linux-Distribution Debian oder Ubunu ist, dann wird standardmäßig die $OSTYPEVariable verwendet.

os='Uknown'
unamestr="${OSTYPE//[0-9.]/}"
os=$( compgen -G "/etc/*release" > /dev/null  && cat /etc/*release | grep ^NAME | tr -d 'NAME="'  ||  echo "$unamestr")

echo "$os"

Wenn Sie Folgendes tun, können Sie die Prüfung für Ubuntu korrekt durchführen:

if [[ "$OSTYPE" =~ ^linux ]]; then
    sudo apt-get install <some-package>
fi