Como detectar o sistema operacional de um script Bash?

Gostaria de manter meus arquivos .bashrce .bash_loginno controle de versão para poder usá-los entre todos os computadores que uso. O problema é que eu tenho alguns aliases específicos do SO, então estava procurando uma maneira de determinar se o script está sendo executado no Mac OS X, Linux ou Cygwin .

Qual é a maneira correta de detectar o sistema operacional em um script Bash ?

Eu acho que o seguinte deve funcionar. Eu não tenho certeza sobre isso win32.

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

Para o meu .bashrc, eu uso o seguinte código:

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

Então eu faço coisas como:

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

É feio, mas funciona. Você pode usar em casevez de, ifse preferir.

A página de manual do bash diz que a variável OSTYPE armazena o nome do sistema operacional:

OSTYPEConfigure automaticamente como uma sequência que descreva o sistema operacional no qual o bash está sendo executado. O padrão é dependente do sistema.

Está definido linux-gnuaqui.

$OSTYPE

Você pode simplesmente usar $OSTYPEvariáveis predefinidas , por exemplo:

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

No entanto, não é reconhecido pelas conchas mais antigas (como a casca de Bourne ).

uname

Outro método é detectar a plataforma com base no unamecomando.

Consulte o seguinte script (pronto para incluir no .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

Você pode encontrar alguns exemplos práticos no meu.bashrc .

Aqui está a versão semelhante usada no 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

Detectar o sistema operacional e o tipo de CPU não é tão fácil de executar de maneira portável . Eu tenho um shscript de cerca de 100 linhas que funciona em uma grande variedade de plataformas Unix: qualquer sistema que eu usei desde 1988.

Os principais elementos são

• uname -pé do tipo processador, mas geralmente está unknownem plataformas modernas do Unix.

• uname -m dará o "nome do hardware da máquina" em alguns sistemas Unix.

• /bin/arch, se existir, geralmente fornecerá o tipo de processador.

• uname sem argumentos nomeará o sistema operacional.

Eventualmente, você terá que pensar nas distinções entre plataformas e em quão bem você deseja torná-las. Por exemplo, apenas para manter as coisas simples, eu trato i386através i686, qualquer " Pentium*" e qualquer " AMD*Athlon*" todos como x86.

Minhas ~/.profile executa um script na inicialização, que define uma variável para uma string, indicando a combinação de CPU e sistema operacional. Tenho específico da plataforma bin, man, lib, e includediretórios que são criadas com base nisso. Depois, defino um monte de variáveis ​​de ambiente. Por exemplo, um script de shell para reformatar o correio pode chamar, por exemplo, $LIB/mailfmtum binário executável específico da plataforma.

Se você deseja cortar custos , o uname -mplain unamelhe dirá o que você quer saber em muitas plataformas. Adicione outras coisas quando precisar. (E use case, não aninhado if!)

Eu recomendo usar este código completo do bash

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

mais exemplos exemplos aqui: https://github.com/coto/server-easy-install/blob/master/lib/core.sh

No bash, use $OSTYPEe $HOSTTYPE, conforme documentado; isto é o que eu faço. Se isso não for suficiente, e se even unameou uname -a(ou outras opções apropriadas) não fornecerem informações suficientes, sempre haverá o script config.guess do projeto GNU, feito exatamente para esse fim.

Eu sugeriria evitar algumas dessas respostas. Não esqueça que você pode escolher outras formas de comparação de strings, o que esclareceria a maioria das variações ou o código feio oferecido.

Uma dessas soluções seria uma verificação simples, como:

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

O qual tem o benefício adicional de corresponder a qualquer versão do Darwin, apesar do sufixo da versão. Isso também funciona para qualquer variação deLinux se possa esperar.

Você pode ver alguns exemplos adicionais nos meus dotfiles aqui

Tente usar "uname". Por exemplo, no Linux: "uname -a".

De acordo com a página do manual, uname está em conformidade com SVr4 e POSIX, portanto deve estar disponível no Mac OS X e Cygwin , mas não posso confirmar isso.

BTW: $ OSTYPE também está definido como linux-gnuaqui :)

Eu escrevi esses açúcares no meu .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" ]];
}

Para que eu possa fazer coisas como:

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

se você quiser mais informações

Eu escrevi uma biblioteca pessoal Bash e uma estrutura de script que usa o GNU shtool para fazer uma detecção de plataforma bastante precisa.

GNU shtool é um conjunto muito portátil de scripts que contém, entre outras coisas úteis, o comando 'shtool platform'. Aqui está a saída de:

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

em algumas máquinas diferentes:

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)

Isso produz resultados bastante satisfatórios, como você pode ver. O GNU shtool é um pouco lento, então eu realmente armazeno e atualizo a identificação da plataforma em um arquivo no sistema que meus scripts chamam. É a minha estrutura, de modo que funciona para mim, mas sua milhagem pode variar.

Agora, você terá que encontrar uma maneira de empacotar o shtool com seus scripts, mas não é um exercício difícil. Você também pode sempre usar a saída uname.

EDITAR:

Perdi o post de Teddy sobre config.guess(de alguma forma). Esses scripts são muito semelhantes, mas não são os mesmos. Eu pessoalmente uso o shtool para outros usos também, e tem funcionado muito bem para mim.

Você pode usar o seguinte:

OS=$(uname -s)

então você pode usar a variável do SO no seu script.

Abaixo está uma abordagem para detectar o SO Linux baseado no Debian e RedHat usando o / etc / lsb-release e / etc / os-release (dependendo do sabor do Linux que você está usando) e executar uma ação simples com base nele.

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

Exemplo de saída para o 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] 
...            

Deve ser seguro usá-lo em todas as distros.

$ cat /etc/*release

Isso produz algo parecido com isto.

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

Extraia / atribua às variáveis ​​como desejar

Nota: Em algumas configurações. Isso também pode fornecer alguns erros que você pode ignorar.

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

tente isto:

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

Você pode usar a seguinte cláusula if e expandi-la conforme necessário:

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

Tentei as mensagens acima em algumas distribuições Linux e achei o seguinte a funcionar melhor para mim. É uma resposta curta e concisa das palavras exatas que também funciona com o Bash no Windows.

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

Costumo manter meus arquivos .bashrc e .bash_alias em um compartilhamento de arquivo que todas as plataformas podem acessar. É assim que eu supero o problema em minhas .bash_alias:

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

E eu tenho, por exemplo, um .bash_alias_Linux com:

alias ls='ls --color=auto'

Dessa forma, mantenho o código específico da plataforma e o portátil separados, você pode fazer o mesmo com o .bashrc

Isso verifica um monte de knownarquivos para identificar se a distribuição Linux é Debian ou Ubunu, e o padrão é a $OSTYPEvariável.

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"

Fazer o seguinte ajudou a executar a verificação corretamente no ubuntu:

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