Jak wykryć system operacyjny ze skryptu Bash?

Chciałbym zachować kontrolę nad plikami .bashrci .bash_loginplikami, aby móc ich używać między wszystkimi komputerami, których używam. Problem polega na tym, że mam pewne aliasy specyficzne dla systemu operacyjnego, więc szukałem sposobu, aby ustalić, czy skrypt działa w systemie Mac OS X, Linux lub Cygwin .

Jaki jest właściwy sposób na wykrycie systemu operacyjnego w skrypcie Bash ?

Myślę, że następujące powinny działać. Nie jestem jednak pewien 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

W moim .bashrc używam następującego kodu:

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

Potem robię coś takiego:

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

Jest brzydka, ale działa. Możesz użyć casezamiast, ifjeśli wolisz.

Strona podręcznika bash mówi, że zmienna OSTYPE przechowuje nazwę systemu operacyjnego:

OSTYPEAutomatycznie ustawiany na ciąg opisujący system operacyjny, w którym wykonywana jest bash. Wartość domyślna zależy od systemu.

Jest ustawiony linux-gnututaj.

$OSTYPE

Możesz po prostu użyć wstępnie zdefiniowanej $OSTYPEzmiennej, np .:

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

Jednak nie jest rozpoznawany przez starsze powłoki (takie jak powłoka Bourne'a ).

uname

Inną metodą jest wykrywanie platformy na podstawie unamepolecenia.

Zobacz następujący skrypt (gotowy do włączenia w .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

Możesz znaleźć praktyczny przykład w moim.bashrc .

Oto podobna wersja używana w 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

Wykrywanie systemu operacyjnego i typu procesora nie jest tak łatwe do przenoszenia . Mam shskrypt około 100 linii, który działa na bardzo szerokiej gamie platform Unix: każdy system, z którego korzystam od 1988 roku.

Kluczowymi elementami są

• uname -pjest typem procesora, ale zwykle znajduje się unknownna nowoczesnych platformach Unix.

• uname -m poda „nazwę sprzętu” na niektórych systemach uniksowych.

• /bin/arch, jeśli istnieje, zwykle podaje typ procesora.

• uname bez argumentów nazwa systemu operacyjnego.

W końcu będziesz musiał pomyśleć o różnicach między platformami i o tym, jak dobrze chcesz je tworzyć. Na przykład, żeby zachować rzeczy proste, traktuję i386przez i686każde „ Pentium*” i każdy „ AMD*Athlon*” wszystko jako x86.

Mój ~/.profileuruchamia skrypt podczas uruchamiania, który ustawia jedną zmienną na ciąg wskazujący kombinację procesora i systemu operacyjnego. Mam od platformy bin, man, lib, i includekatalogi, które uzyskać utworzone na podstawie tego. Następnie ustawiam zestaw zmiennych środowiskowych. Na przykład skrypt powłoki w celu przeformatowania poczty może wywoływać np. $LIB/mailfmtSpecyficzny dla platformy plik binarny wykonywalny.

Jeśli chcesz skracać rogi , uname -ma zwykły unamepoinformuje Cię, co chcesz wiedzieć na wielu platformach. Dodaj inne rzeczy, kiedy ich potrzebujesz. (I użyj case, nie zagnieżdżony if!)

Polecam użyć tego pełnego kodu 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

więcej przykładów tutaj: https://github.com/coto/server-easy-install/blob/master/lib/core.sh

W bashu używaj $OSTYPEi $HOSTTYPE, jak udokumentowano; to jest to, co robie. Jeśli to nie wystarczy, a nawet unamelub uname -a(lub inne odpowiednie opcje) nie dają wystarczających informacji, zawsze jest skrypt config.guess z projektu GNU, stworzony specjalnie do tego celu.

Sugerowałbym unikanie niektórych z tych odpowiedzi. Nie zapominaj, że możesz wybrać inne formy porównywania ciągów, które wyczyściłyby większość wariantów lub oferował brzydki kod.

Jednym z takich rozwiązań byłoby proste sprawdzenie, takie jak:

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

Co ma tę dodatkową zaletę, że pasuje do dowolnej wersji Darwina, pomimo sufiksu wersji. Działa to również w przypadku każdej odmiany, Linuxjakiej można się spodziewać.

Możesz zobaczyć dodatkowe przykłady w moich plikach dot tutaj

Spróbuj użyć „uname”. Na przykład w systemie Linux: „uname -a”.

Według strony podręcznika, uname jest zgodny z SVr4 i POSIX, więc powinien być dostępny również w Mac OS X i Cygwin , ale nie mogę tego potwierdzić.

BTW: $ OSTYPE jest również ustawione linux-gnututaj :)

Te cukry napisałem w moim .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" ]];
}

Więc mogę robić takie rzeczy jak:

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

lub

uname -a

jeśli chcesz więcej informacji

Napisałem osobistą bibliotekę Bash i platformę skryptową, która wykorzystuje GNU shtool do dość dokładnego wykrywania platformy.

GNU shtool to bardzo przenośny zestaw skryptów, który zawiera między innymi przydatne polecenie „platforma shtool”. Oto wynik:

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

na kilku różnych maszynach:

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)

Jak widać, daje to całkiem zadowalające wyniki. GNU shtool jest trochę wolny, więc właściwie przechowuję i aktualizuję identyfikację platformy w pliku w systemie, który wywołują moje skrypty. To moja platforma, więc działa dla mnie, ale twój przebieg może się różnić.

Teraz musisz znaleźć sposób na spakowanie shtoola za pomocą swoich skryptów, ale nie jest to trudne zadanie. Zawsze możesz również polegać na wyjściu uname.

EDYTOWAĆ:

Brakowało mi posta Teddy'ego o config.guess(jakoś). Są to bardzo podobne skrypty, ale nie takie same. Osobiście używam shtoola również do innych celów i działa całkiem dobrze dla mnie.

Możesz użyć następujących opcji:

OS=$(uname -s)

wtedy możesz użyć zmiennej OS w swoim skrypcie.

Poniżej znajduje się podejście do wykrywania systemu operacyjnego Linux opartego na Debian i RedHat przy użyciu / etc / lsb-release i / etc / os-release (w zależności od używanego smaku Linuksa) i podjęcie na jego podstawie prostej akcji.

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

Przykład danych wyjściowych dla systemu 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] 
...            

Powinno to być bezpieczne w użyciu na wszystkich dystrybucjach.

$ cat /etc/*release

To produkuje coś takiego.

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

Wyodrębnij / przypisz do zmiennych, jak chcesz

Uwaga: w niektórych konfiguracjach. Może to również powodować błędy, które możesz zignorować.

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

Spróbuj tego:

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

Możesz użyć następującej klauzuli if i rozwinąć ją w razie potrzeby:

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

Wypróbowałem powyższe komunikaty w kilku dystrybucjach Linuksa i znalazłem następujące, które działają najlepiej dla mnie. To krótka, zwięzła, dokładna odpowiedź na słowo, która działa również w Bash na Windowsie.

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

Staram się przechowywać pliki .bashrc i .bash_alias w udziale plików, do którego mają dostęp wszystkie platformy. Oto jak pokonałem problem w mojej .bash_alias:

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

I mam na przykład .bash_alias_Linux z:

alias ls='ls --color=auto'

W ten sposób oddzielam kod specyficzny dla platformy i przenośny, możesz zrobić to samo dla .bashrc

Sprawdza to kilka knownplików w celu ustalenia, czy dystrybucją Linuksa jest Debian lub Ubunu, a następnie domyślnie jest to $OSTYPEzmienna.

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"

Wykonanie następujących czynności pomogło poprawnie wykonać sprawdzenie Ubuntu:

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