Comment détecter le système d'exploitation à partir d'un script Bash?

Je souhaite conserver mes fichiers .bashrcet .bash_loginsous contrôle de version afin de pouvoir les utiliser entre tous les ordinateurs que j'utilise. Le problème est que j'ai des alias spécifiques au système d'exploitation, donc je cherchais un moyen de déterminer si le script s'exécute sur Mac OS X, Linux ou Cygwin .

Quelle est la bonne façon de détecter le système d'exploitation dans un script Bash ?

Je pense que ce qui suit devrait fonctionner. Je ne suis pas sûr win32cependant.

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

Pour mon .bashrc, j'utilise le code suivant:

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

Ensuite, je fais des choses comme:

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

C'est moche, mais ça marche. Vous pouvez utiliser caseau lieu de ifsi vous préférez.

La page de manuel bash indique que la variable OSTYPE stocke le nom du système d'exploitation:

OSTYPEDéfini automatiquement sur une chaîne qui décrit le système d'exploitation sur lequel bash s'exécute. La valeur par défaut dépend du système.

C'est réglé linux-gnuici.

$OSTYPE

Vous pouvez simplement utiliser une $OSTYPEvariable prédéfinie , par exemple:

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

Cependant, il n'est pas reconnu par les coquilles plus anciennes (comme la coquille Bourne ).

uname

Une autre méthode consiste à détecter la plateforme sur la base d'une unamecommande.

Voir le script suivant (prêt à être inclus dans .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

Vous pouvez trouver un exemple pratique dans mon.bashrc .

Voici une version similaire utilisée sur 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

Détecter le système d'exploitation et le type de CPU n'est pas si facile à faire de manière portable . J'ai un shscript d'environ 100 lignes qui fonctionne sur une très grande variété de plates-formes Unix: tout système que j'utilise depuis 1988.

Les éléments clés sont

• uname -pest de type processeur, mais se trouve généralement unknownsur les plateformes Unix modernes.

• uname -m donnera le "nom du matériel de la machine" sur certains systèmes Unix.

• /bin/arch, s'il existe, donnera généralement le type de processeur.

• uname sans argument nommera le système d'exploitation.

Finalement, vous devrez penser aux distinctions entre les plates-formes et à quel point vous voulez les faire. Par exemple, juste pour garder les choses simples de, je traite à i386travers i686, tout « Pentium*» et tout « AMD*Athlon*» tout comme x86.

My ~/.profileexécute un script au démarrage qui définit une variable sur une chaîne indiquant la combinaison du processeur et du système d'exploitation. Je plate-forme spécifique bin, man, libet les includerépertoires qui se mettent en place sur cette base. Ensuite, j'ai défini une cargaison de variables d'environnement. Ainsi, par exemple, un script shell pour reformater le courrier peut appeler, par exemple, $LIB/mailfmtqui est un binaire exécutable spécifique à la plate-forme.

Si vous voulez couper les coins ronds , uname -mplain unamevous dira ce que vous voulez savoir sur de nombreuses plateformes. Ajoutez d'autres éléments lorsque vous en avez besoin. (Et utilisez case, pas imbriqué if!)

Je recommande d'utiliser ce code bash complet

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

plus d'exemples d'exemples ici: https://github.com/coto/server-easy-install/blob/master/lib/core.sh

En bash, utilisez $OSTYPEet $HOSTTYPE, comme documenté; c'est ce que je fais. Si cela ne suffit pas et si even unameou uname -a(ou d'autres options appropriées) ne donnent pas suffisamment d'informations, il y a toujours le script config.guess du projet GNU, conçu exactement à cet effet.

Je suggérerais d'éviter certaines de ces réponses. N'oubliez pas que vous pouvez choisir d'autres formes de comparaison de chaînes, ce qui éliminerait la plupart des variations ou du code laid offert.

Une telle solution serait une simple vérification, telle que:

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

Ce qui a l'avantage supplémentaire de correspondre à n'importe quelle version de Darwin, malgré son suffixe de version. Cela fonctionne également pour toutes les variations que l' Linuxon peut attendre.

Vous pouvez voir quelques exemples supplémentaires dans mes fichiers dot ici

Essayez d'utiliser "uname". Par exemple, sous Linux: "uname -a".

Selon la page de manuel, uname est conforme à SVr4 et POSIX, donc il devrait être disponible sur Mac OS X et Cygwin aussi, mais je ne peux pas le confirmer.

BTW: $ OSTYPE est également défini linux-gnuici :)

J'ai écrit ces sucres dans mon .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" ]];
}

Je peux donc faire des trucs comme:

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

ou

uname -a

si vous voulez plus d'informations

J'ai écrit une bibliothèque Bash personnelle et un framework de script qui utilise GNU shtool pour effectuer une détection de plateforme plutôt précise.

GNU shtool est un ensemble de scripts très portable qui contient, entre autres choses utiles, la commande 'shtool platform'. Voici la sortie de:

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

sur quelques machines différentes:

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)

Cela produit des résultats assez satisfaisants, comme vous pouvez le voir. GNU shtool est un peu lent, donc je stocke et mets à jour l'identification de la plateforme dans un fichier sur le système que mes scripts appellent. C'est mon cadre, donc cela fonctionne pour moi, mais votre kilométrage peut varier.

Maintenant, vous devrez trouver un moyen d'empaqueter shtool avec vos scripts, mais ce n'est pas un exercice difficile. Vous pouvez toujours vous rabattre sur la sortie sans nom.

ÉDITER:

J'ai raté le message de Teddy sur config.guess(en quelque sorte). Ce sont des scripts très similaires, mais pas les mêmes. Personnellement, j'utilise également shtool pour d'autres utilisations, et cela a très bien fonctionné pour moi.

Vous pouvez utiliser les éléments suivants:

OS=$(uname -s)

alors vous pouvez utiliser la variable OS dans votre script.

Ci-dessous, vous trouverez une approche pour détecter le système d'exploitation Linux basé sur Debian et RedHat en utilisant la version / etc / lsb et / etc / os-release (selon la version Linux que vous utilisez) et prendre une action simple en fonction de celle-ci.

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

Exemple de sortie pour 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] 
...            

Cela devrait être sûr à utiliser sur toutes les distributions.

$ cat /etc/*release

Cela produit quelque chose comme ça.

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

Extraire / assigner aux variables comme vous le souhaitez

Remarque: sur certaines configurations. Cela peut également vous donner des erreurs que vous pouvez ignorer.

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

essaye ça:

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

Vous pouvez utiliser la clause if suivante et la développer si nécessaire:

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

J'ai essayé les messages ci-dessus sur quelques distributions Linux et j'ai trouvé que ce qui suit fonctionnait le mieux pour moi. C'est une réponse exacte et concise qui fonctionne également pour Bash sous Windows.

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

J'ai tendance à conserver mes .bashrc et .bash_alias sur un partage de fichiers auquel toutes les plateformes peuvent accéder. Voici comment je vaincre le problème dans mon .bash_alias:

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

Et j'ai par exemple un .bash_alias_Linux avec:

alias ls='ls --color=auto'

De cette façon, je garde le code spécifique à la plate-forme et le code portable séparés, vous pouvez faire de même pour .bashrc

Cela vérifie un tas de knownfichiers pour identifier si la distribution linux est Debian ou Ubunu, puis elle est par défaut la $OSTYPEvariable.

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"

Les opérations suivantes ont aidé à effectuer correctement la vérification d'ubuntu:

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