Pracuję nad prostym skryptem bash, który powinien być w stanie uruchomić na dystrybucjach Ubuntu i CentOS (wsparcie dla Debiana i Fedory / RHEL byłoby plusem) i muszę znać nazwę i wersję dystrybucji, w której działa skrypt ( w celu uruchomienia określonych działań, na przykład tworzenia repozytoriów). Jak dotąd mam to:

OS=$(awk '/DISTRIB_ID=/' /etc/*-release | sed 's/DISTRIB_ID=//' | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m | sed 's/x86_//;s/i[3-6]86/32/')
VERSION=$(awk '/DISTRIB_RELEASE=/' /etc/*-release | sed 's/DISTRIB_RELEASE=//' | sed 's/[.]0/./')

if [ -z "$OS" ]; then
    OS=$(awk '{print $1}' /etc/*-release | tr '[:upper:]' '[:lower:]')
fi

if [ -z "$VERSION" ]; then
    VERSION=$(awk '{print $3}' /etc/*-release)
fi

echo $OS
echo $ARCH
echo $VERSION

Wygląda na to, że działa, powraca ubuntulub centos(nie próbowałem innych) jako nazwa wydania. Mam jednak wrażenie, że musi istnieć łatwiejszy i bardziej niezawodny sposób na znalezienie tego - czy to prawda?

To nie działa dla RedHat. / etc / redhat-release zawiera: Redhat Linux Entreprise wydanie 5.5

Więc wersja nie jest trzecim słowem, lepiej użyj:

OS_MAJOR_VERSION=`sed -rn 's/.*([0-9])\.[0-9].*/\1/p' /etc/redhat-release`
OS_MINOR_VERSION=`sed -rn 's/.*[0-9].([0-9]).*/\1/p' /etc/redhat-release`
echo "RedHat/CentOS $OS_MAJOR_VERSION.$OS_MINOR_VERSION"

Aby uzyskać OSi VER, wydaje się, że najnowszy standard /etc/os-release. Wcześniej było lsb_releasei /etc/lsb-release. Wcześniej trzeba było szukać różnych plików dla każdej dystrybucji.

Oto, co zasugeruję

if [ -f /etc/os-release ]; then
    # freedesktop.org and systemd
    . /etc/os-release
    OS=$NAME
    VER=$VERSION_ID
elif type lsb_release >/dev/null 2>&1; then
    # linuxbase.org
    OS=$(lsb_release -si)
    VER=$(lsb_release -sr)
elif [ -f /etc/lsb-release ]; then
    # For some versions of Debian/Ubuntu without lsb_release command
    . /etc/lsb-release
    OS=$DISTRIB_ID
    VER=$DISTRIB_RELEASE
elif [ -f /etc/debian_version ]; then
    # Older Debian/Ubuntu/etc.
    OS=Debian
    VER=$(cat /etc/debian_version)
elif [ -f /etc/SuSe-release ]; then
    # Older SuSE/etc.
    ...
elif [ -f /etc/redhat-release ]; then
    # Older Red Hat, CentOS, etc.
    ...
else
    # Fall back to uname, e.g. "Linux <version>", also works for BSD, etc.
    OS=$(uname -s)
    VER=$(uname -r)
fi

Myślę, że unameaby dostać się ARCHjest nadal najlepszym sposobem. Ale podany przez ciebie przykład oczywiście dotyczy tylko systemów Intel. Nazwałbym to BITStak:

case $(uname -m) in
x86_64)
    BITS=64
    ;;
i*86)
    BITS=32
    ;;
*)
    BITS=?
    ;;
esac

Lub zmień ARCHna bardziej popularne, ale jednoznaczne wersje: x86i x64podobne:

case $(uname -m) in
x86_64)
    ARCH=x64  # or AMD64 or Intel64 or whatever
    ;;
i*86)
    ARCH=x86  # or IA32 or Intel32 or whatever
    ;;
*)
    # leave ARCH as-is
    ;;
esac

ale oczywiście to zależy od ciebie.

Chciałbym to zrobić jako pierwszy krok:

ls /etc/*release

Gentoo, RedHat, Arch i SuSE mają plik o nazwie np /etc/gentoo-release. Wydaje się być popularny, sprawdź tę stronę o plikach wydania .

Debian i Ubuntu powinny również /etc/lsb-releasezawierać informacje o wydaniu i będą wyświetlane z poprzednim poleceniem.

Kolejny szybki to uname -rv. Jeśli zainstalowane jądro jest standardowym jądrem dystrybucji, zwykle znajdziesz tam nazwę.

lsb_release -a. Działa na Debianie i chyba Ubuntu, ale nie jestem pewien co do reszty. Zwykle powinien istnieć we wszystkich dystrybucjach GNU / Linux, ponieważ jest związany z LSB (Linux Standard Base).

Jednowarstwowy, awarie, jedna linia wyników, bez błędów.

lsb_release -ds 2>/dev/null || cat /etc/*release 2>/dev/null | head -n1 || uname -om

python -c "import platform;print(platform.platform())"

Lub tylko

python -m platform

1. lsb- * nie jest zainstalowany / nie istnieje na podstawowych systemach CentOS lub Debian
2. / proc / * nie istnieje w OSX

Weź napiwek od programistów javascript. Nie testuj wersji, testuj możliwości. To nie jest ładne, ale działa. Rozwiń w razie potrzeby.

function os_type
{
case `uname` in
  Linux )
     LINUX=1
     which yum && { echo centos; return; }
     which zypper && { echo opensuse; return; }
     which apt-get && { echo debian; return; }
     ;;
  Darwin )
     DARWIN=1
     ;;
  * )
     # Handle AmgiaOS, CPM, and modified cable modems here.
     ;;
esac
}  

W kolejności najbardziej prawdopodobnego sukcesu:

cat /etc/*version
cat /proc/version #linprocfs/version for FreeBSD when "linux" enabled
cat /etc/*release
uname -rv

obejmuje większość przypadków (AFAIK): Debian, Ubuntu, Slackware, Suse, Redhat, Gentoo, * BSD i być może inne.

W przypadku większości współczesnych systemów Linux, plik /etc/os-releasenaprawdę staje się standardem i włącza się do większości systemów operacyjnych. Tak więc w skrypcie Bash możesz po prostu dołączyć plik i będziesz mieć dostęp do wszystkich opisanych tutaj zmiennych (na przykład: NAZWA, WERSJA, ...)

Używam tego w moim skrypcie Bash:

if [ -f /etc/os-release ]
then
        . /etc/os-release
else
        echo "ERROR: I need the file /etc/os-release to determine what my distribution is..."
        # If you want, you can include older or distribution specific files here...
        exit
fi

Jeśli plik /etc/debian_versionistnieje, dystrybucja to Debian lub pochodna Debiana. Ten plik może mieć numer wydania; na moim komputerze jest obecnie 6.0.1. Jeśli jest testowany lub niestabilny, może powiedzieć testowanie / niestabilny lub może mieć numer nadchodzącego wydania. Mam wrażenie, że przynajmniej na Ubuntu ten plik zawsze testuje / jest niestabilny i że nie umieszczają w nim numeru wydania, ale ktoś może mnie poprawić, jeśli się mylę.

Fedora (przynajmniej ostatnie wydania) mają podobny plik, a mianowicie /etc/fedora-release.

Jeśli nie możesz lub nie chcesz używać pliku wydania LSB (ze względu na zależności, które wprowadza pakiet), możesz poszukać plików wydania specyficznych dla dystrybucji. Bcfg2 ma sondę dla dystrybucji, której możesz użyć: http://trac.mcs.anl.gov/projects/bcfg2/browser/doc/server/plugins/probes/group.txt

2 sposoby z wielu:

1) użyj

lsb_release -a

Przetestowałem to na CentOS 5.5 i Ubuntu 10.04

wyjście dla CentOS to:

LSB Version:    :core-3.1-ia32:core-3.1-noarch:graphics-3.1-ia32:graphics-3.1-noarch 
Distributor ID: CentOS
Description:    CentOS release 5.5 (Final)
Release:        5.5
Codename:       Final

a dla Ubuntu jest:

LSB Version:    :core-3.1-ia32:core-3.1-noarch:graphics-3.1-ia32:graphics-3.1-noarch
Distributor ID: CentOS
Description:    CentOS release 5.5 (Final)
Release:        5.5
Codename:       Final

2) wprowadź następujące polecenie:

cat /etc/*-release

Przetestowałem to na CentOS 5.5 i Ubuntu 10.04 i działa dobrze.

Ten skrypt działa na Debianie (może wymagać drobnych poprawek w Ubuntu)

#!/usr/bin/env bash

echo "Finding Debian/ Ubuntu Codename..."

CODENAME=`cat /etc/*-release | grep "VERSION="`
CODENAME=${CODENAME##*\(}
CODENAME=${CODENAME%%\)*}

echo "$CODENAME"
# => saucy, precise, lucid, wheezy, squeeze

Oto moja prosta wersja chech_distro. ^^;

#!/usr/bin/env bash
check_distro2(){
    if [[ -e /etc/redhat-release ]]
    then
      DISTRO=$(cat /etc/redhat-release)
    elif [[ -e /usr/bin/lsb_release ]]
    then
      DISTRO=$(lsb_release -d | awk -F ':' '{print $2}')
    elif [[ -e /etc/issue ]]
    then
      DISTRO=$(cat /etc/issue)
    else
      DISTRO=$(cat /proc/version)
    fi
    }

    check_distro2
    echo $DISTRO

Bez wersji wystarczy tylko dist:

cat /etc/issue | head -n +1 | awk '{print $1}'

Zostało to przetestowane na Ubuntu 14 i CentOS 7

cat /etc/os-release | grep "PRETTY_NAME" | sed 's/PRETTY_NAME=//g' | sed 's/["]//g' | awk '{print $1}'

Znajduję stąd dobry skrypt , który działa na większość popularnych Linuksów:

#! /bin/bash
# return an awkable string consisting of
#    unix OS type, or
#    Linux dist, or
#    a long guess (based on /proc), or
#    no clue

giveUp () {
   echo "Unknown"
   exit 0
}

# keep this easily awkable, prepending an initial clue
versionGuess () {
   if [ -e /proc/version ]; then
      echo -n "Unsure "
      cat /proc/version
      exit 0
   fi
   return 1
}

# if we have ignition, print and exit
gotDist () {
   [ -n "$1" ] && echo "$1" && exit 0
}

# we are only interested in a single word "dist" here
# various malformations can occur; admin will have to code appropately based on output
linuxRelease () {
   if [ -r /etc/lsb-release ]; then
      dist=$(grep 'DISTRIB_ID' /etc/lsb-release | sed 's/DISTRIB_ID=//' | head -1)
      gotDist "$dist"
   fi

   dist=$(find /etc/ -maxdepth 1 -name '*release' 2> /dev/null | sed 's/\/etc\///' | sed 's/-release//' | head -1)
   gotDist "$dist"

   dist=$(find /etc/ -maxdepth 1 -name '*version' 2> /dev/null | sed 's/\/etc\///' | sed 's/-version//' | head -1)
   gotDist "$dist"

   return 1
}

# start with uname and branch the decision from there
dist=$(uname -s 2> /dev/null)
if [ "$dist" = "Linux" ]; then
   linuxRelease
   versionGuess
   giveUp
elif [ -n "$dist" ]; then
   echo "$dist"
   exit 0
else
   versionGuess
   giveUp
fi

# we shouldn't get here
giveUp
# done

Używam narzędzia skryptowego Screenfetch :

Jest rubinowy klejnot faktera , który podaje kilka faktów na temat systemu operacyjnego, analizuje pliki wersji systemu operacyjnego, inne dane i drukuje na ekranie terminala. Możesz spróbować w następujący sposób, zaczynając od instalacji rubygemów:

# apt-get install rubygems

Użyj powyższego przypadku, który jest odpowiedni dla twojego systemu operacyjnego. Następnie zainstaluj sam klejnot.

# gem install facter

Następnie użyj:

$ facter

UWAGA: Zobacz źródła klejnotów w celu uzyskania dodatkowych informacji podczas instalacji.

Jeśli ktoś również potrzebuje dystrybucji:

#!/usr/bin/env bash

LINUX_VERSION_NAME=`lsb_release -sr`


# Distribution specific installation
if [[ ${LINUX_VERSION_NAME} == "18.04" ]]
then
    echo "It is: ${LINUX_VERSION_NAME}"

else
    echo "It is not ${LINUX_VERSION_NAME}"
fi

Wynik:

It is: 18.04

Zmień na: lsb_release -sc, aby uzyskać dystrybucję:

LINUX_VERSION_NAME=`lsb_release -sc`


# Distribution specific installation
if [[ ${LINUX_VERSION_NAME} == "bionic" ]]
then
    echo "It is: ${LINUX_VERSION_NAME}"

else
    echo "It is not ${LINUX_VERSION_NAME}"
fi

Wynik:

It is: bionic

To polecenie działa w przypadku dystrybucji opartych na Debianie i Redhat: Korzystając z trfiltra, konwertujesz dokument do formatu jednego słowa na linię, a następnie zliczasz pierwszy wiersz zawierający nazwę dystrybucji.

tr -s ' \011' '\012' < /etc/issue | head -n 1