Come rilevare il sistema operativo da uno script Bash?

Vorrei mantenere il mio .bashrce i .bash_loginfile nel controllo della versione in modo da poterli usare tra tutti i computer che uso. Il problema è che ho alcuni alias specifici del sistema operativo, quindi stavo cercando un modo per determinare se lo script è in esecuzione su Mac OS X, Linux o Cygwin .

Qual è il modo corretto di rilevare il sistema operativo in uno script Bash ?

Penso che dovrebbe funzionare quanto segue. Non sono sicuro win32però.

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

Per il mio .bashrc, utilizzo il seguente codice:

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

Quindi faccio qualcosa come:

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

È brutto, ma funziona. Puoi usare caseinvece di ifse preferisci.

La manpage bash dice che la variabile OSTYPE memorizza il nome del sistema operativo:

OSTYPEImpostato automaticamente su una stringa che descrive il sistema operativo su cui è in esecuzione bash. L'impostazione predefinita dipende dal sistema.

È impostato linux-gnuqui.

$OSTYPE

Puoi semplicemente usare una $OSTYPEvariabile predefinita , ad esempio:

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

Tuttavia, non è riconosciuto dalle shell più vecchie (come la shell Bourne ).

uname

Un altro metodo è rilevare la piattaforma in base al unamecomando.

Vedi il seguente script (pronto per essere incluso in .bashrc):

# 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

Puoi trovare alcuni esempi pratici nel mio.bashrc .

Ecco una versione simile utilizzata su Travis CI :

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

Rilevare il sistema operativo e il tipo di CPU non è così facile da eseguire in modo portabile . Ho una shsceneggiatura di circa 100 linee che funziona su un'ampia varietà di piattaforme Unix: qualsiasi sistema che ho usato dal 1988.

Gli elementi chiave sono

• uname -pè di tipo processore ma di solito è unknownsu moderne piattaforme Unix.

• uname -m darà il "nome hardware della macchina" su alcuni sistemi Unix.

• /bin/arch, se esiste, di solito fornisce il tipo di processore.

• uname senza argomenti nominerà il sistema operativo.

Alla fine dovrai pensare alle distinzioni tra piattaforme e quanto bene vuoi farle. Ad esempio, solo per mantenere le cose semplici, mi trattano i386tramite i686, qualsiasi " Pentium*" e qualsiasi " AMD*Athlon*" tutti come x86.

My ~/.profileesegue uno script all'avvio che imposta una variabile su una stringa che indica la combinazione di CPU e sistema operativo. Ho piattaforma specifica bin, man, lib, e includele directory che vengono impostati sulla base di tale. Quindi ho impostato un carico di variabili d'ambiente. Quindi, ad esempio, uno script di shell per riformattare la posta può chiamare, ad esempio, $LIB/mailfmtche è un binario eseguibile specifico della piattaforma.

Se vuoi tagliare gli angoli , uname -me Plain unameti dirà cosa vuoi sapere su molte piattaforme. Aggiungi altre cose quando ne hai bisogno. (E usare case, non nidificato if!)

Consiglio di usare questo codice bash completo

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

altri esempi esempi qui: https://github.com/coto/server-easy-install/blob/master/lib/core.sh

In bash, usa $OSTYPEe $HOSTTYPE, come documentato; questo è ciò che faccio. Se ciò non è abbastanza e se pari unameo uname -a(o altre opzioni appropriate) non forniscono abbastanza informazioni, c'è sempre lo script config.guess del progetto GNU, creato esattamente per questo scopo.

Suggerirei di evitare alcune di queste risposte. Non dimenticare che puoi scegliere altre forme di confronto tra stringhe, che chiarirebbero la maggior parte delle variazioni o il brutto codice offerto.

Una di queste soluzioni sarebbe un semplice controllo, come ad esempio:

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

Il che ha l'ulteriore vantaggio di abbinare qualsiasi versione di Darwin, nonostante sia il suffisso della versione. Questo funziona anche per eventuali variazioni che Linuxuno può aspettarsi.

Puoi vedere alcuni esempi aggiuntivi nei miei dotfile qui

Prova a utilizzare "uname". Ad esempio, in Linux: "uname -a".

Secondo la pagina del manuale, uname è conforme a SVr4 e POSIX, quindi dovrebbe essere disponibile anche su Mac OS X e Cygwin , ma non posso confermarlo.

A proposito: $ OSTYPE è impostato anche linux-gnuqui :)

Ho scritto questi zuccheri nel mio .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" ]];
}

Quindi posso fare cose come:

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

o

uname -a

se vuoi maggiori informazioni

Ho scritto una libreria personale di Bash e un framework di scripting che utilizza GNU shtool per eseguire un rilevamento della piattaforma piuttosto accurato.

GNU shtool è un set di script molto portabile che contiene, tra le altre cose utili, il comando 'shtool platform'. Ecco l'output di:

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

su alcune macchine diverse:

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)

Questo produce risultati abbastanza soddisfacenti, come puoi vedere. GNU shtool è un po 'lento, quindi in realtà memorizzo e aggiorno l'identificazione della piattaforma in un file sul sistema che i miei script chiamano. È il mio framework, quindi funziona per me, ma il tuo chilometraggio può variare.

Ora dovrai trovare un modo per impacchettare shtool con i tuoi script, ma non è un esercizio difficile. Puoi sempre ripiegare su output uname, anche.

MODIFICARE:

Mi mancava il post di Teddy config.guess(in qualche modo). Questi sono script molto simili, ma non uguali. Personalmente uso shtool anche per altri usi, e ha funzionato abbastanza bene per me.

È possibile utilizzare quanto segue:

OS=$(uname -s)

allora puoi usare la variabile OS nel tuo script.

Di seguito è riportato un approccio per rilevare il sistema operativo Linux basato su Debian e RedHat usando le versioni / etc / lsb e / etc / os (a seconda del tipo di Linux che si sta utilizzando) e fare una semplice azione basata su di esso.

#!/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

Esempio di output per 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] 
...            

Questo dovrebbe essere sicuro da usare su tutte le distro.

$ cat /etc/*release

Questo produce qualcosa del genere.

     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/"

Estrai / assegna alle variabili come desideri

Nota: su alcune configurazioni. Questo potrebbe anche darti alcuni errori che puoi ignorare.

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

prova questo:

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

È possibile utilizzare la seguente clausola if ed espanderla secondo necessità:

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

Ho provato i messaggi di cui sopra in alcune distro Linux e ho trovato quanto segue per funzionare meglio per me. È una risposta breve, concisa e precisa, che funziona anche con Bash su Windows.

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

Tendo a mantenere i miei .bashrc e .bash_alias su una condivisione file a cui tutte le piattaforme possono accedere. È così che vinco il problema nel mio .bash_alias:

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

E ho ad esempio un .bash_alias_Linux con:

alias ls='ls --color=auto'

In questo modo mantengo separato il codice specifico della piattaforma e portatile, puoi fare lo stesso per .bashrc

Questo controlla un mucchio di knownfile per identificare se la distribuzione Linux è Debian o Ubunu, quindi per impostazione predefinita è la $OSTYPEvariabile.

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"

Fare quanto segue ha aiutato a eseguire correttamente il controllo per Ubuntu:

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