Eu tentei com:
cat /etc/*release | grep "^ID="
E eu tenho isso com o Ubuntu e o Centos também.
Estou aprendendo os fundamentos do script e tentando escrever um script para decidir em que tipo de script o Linux é executado. Eu criei uma versão simples da seguinte forma:
#!/bin/sh
which yum >/dev/null && { echo Fedora flavour; exit 0; }
which zypper >/dev/null && { echo Suse of sorts; exit 0; }
which apt-get >/dev/null && { echo Debian based; }
Existe uma maneira mais elegante de decidir qual sabor do Linux estou usando? Existe uma maneira de incluir o Unix - ou torná-lo genérico para qualquer tipo de Xnix?
Muito obrigado.
Edit: esta não é uma duplicata de Como um identificar a distribuição linux em uso? pelas seguintes razões:
Para o Ubuntu, cat /etc/lsb-release funciona como um encanto, para RedHat, isso não acontece.
ls /etc/*release faz, mas lista três pastas. cat /proc/version parece promissor, mas precisa de alguma mágica regex.
Eu tentei com:
cat /etc/*release | grep "^ID="
E eu tenho isso com o Ubuntu e o Centos também.
Vou compartilhar o código de um script que estou fazendo, que suporta mais de 12 sistemas Linux diferentes e detecta se o sistema é baseado em armas. No começo há um array no qual você deve colocar o linux que você suporta. Tem duas fases. Primeiro é procurar as palavras no array contra a saída do comando uname. E o segundo é verificar o especial existente em / etc que depende da distro.
#!/bin/bash
is_arm=0
#Distros vars
known_compatible_distros=(
"Wifislax"
"Kali"
"Parrot"
"Backbox"
"Blackarch"
"Cyborg"
"Ubuntu"
"Debian"
"SuSE"
"CentOS"
"Gentoo"
"Fedora"
"Red Hat"
"Arch"
"OpenMandriva"
)
known_arm_compatible_distros=(
"Raspbian"
"Parrot arm"
"Kali arm"
)
#First phase of Linux distro detection based on uname output
function detect_distro_phase1() {
for i in "${known_compatible_distros[@]}"; do
uname -a | grep "${i}" -i > /dev/null
if [ "$?" = "0" ]; then
distro="${i^}"
break
fi
done
}
#Second phase of Linux distro detection based on architecture and version file
function detect_distro_phase2() {
if [ "${distro}" = "Unknown Linux" ]; then
if [ -f ${osversionfile_dir}"centos-release" ]; then
distro="CentOS"
elif [ -f ${osversionfile_dir}"fedora-release" ]; then
distro="Fedora"
elif [ -f ${osversionfile_dir}"gentoo-release" ]; then
distro="Gentoo"
elif [ -f ${osversionfile_dir}"openmandriva-release" ]; then
distro="OpenMandriva"
elif [ -f ${osversionfile_dir}"redhat-release" ]; then
distro="Red Hat"
elif [ -f ${osversionfile_dir}"SuSE-release" ]; then
distro="SuSE"
elif [ -f ${osversionfile_dir}"debian_version" ]; then
distro="Debian"
if [ -f ${osversionfile_dir}"os-release" ]; then
extra_os_info=$(cat < ${osversionfile_dir}"os-release" | grep "PRETTY_NAME")
if [[ "${extra_os_info}" =~ Raspbian ]]; then
distro="Raspbian"
is_arm=1
elif [[ "${extra_os_info}" =~ Parrot ]]; then
distro="Parrot arm"
is_arm=1
fi
fi
fi
fi
detect_arm_architecture
}
#Detect if arm architecture is present on system
function detect_arm_architecture() {
distro_already_known=0
uname -m | grep -i "arm" > /dev/null
if [[ "$?" = "0" ]] && [[ "${distro}" != "Unknown Linux" ]]; then
for item in "${known_arm_compatible_distros[@]}"; do
if [ "${distro}" = "${item}" ]; then
distro_already_known=1
fi
done
if [ ${distro_already_known} -eq 0 ]; then
distro="${distro} arm"
is_arm=1
fi
fi
}
detect_distro_phase1
detect_distro_phase2
echo "${distro}"
echo "${is_arm}"
Claro que pode ser melhorado ... talvez mudando a cadeia "elif" para um caso ou para esse tipo de coisa ... mas isso está funcionando perfeitamente. Espero que ajude a você.
Então, fiquei preso a isso e depois de um dia de escavação achei isso: link
Em seguida, outro trabalho / mesclagem e testes de um dia resultaram no seguinte script que foi testado para ser executado em
Se algum de vocês tiver uma maneira de verificar quaisquer outras distros, eu ficaria muito grato.
#!/bin/sh
# Detects which OS and if it is Linux then it will detect which Linux
# Distribution.
# from http://linuxmafia.com/faq/Admin/release-files.html
#
OS='uname -s'
REV='uname -r'
MACH='uname -m'
GetVersionFromFile()
{
VERSION='cat $1 | tr "\n" ' ' | sed s/.*VERSION.*=\ // '
}
if [ "${OS}" = "Darwin" ]; then
OIFS="$IFS"
IFS=$'\n'
set 'sw_vers' > /dev/null
DIST='echo $1 | tr "\n" ' ' | sed 's/ProductName:[ ]*//''
VERSION='echo $2 | tr "\n" ' ' | sed 's/ProductVersion:[ ]*//''
BUILD='echo $3 | tr "\n" ' ' | sed 's/BuildVersion:[ ]*//''
OSSTR="${OS} ${DIST} ${REV}(SORRY_NO_PSEUDONAME ${BUILD} ${MACH})"
IFS="$OIFS"
elif [ "${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
KERNEL='uname -r'
if [ -f /etc/redhat-release ] ; then
DIST='RedHat'
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
DIST='cat /etc/SuSE-release | tr "\n" ' '| sed s/VERSION.*//'
REV='cat /etc/SuSE-release | tr "\n" ' ' | sed s/.*=\ //'
elif [ -f /etc/mandrake-release ] ; then
DIST='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
DIST="Debian 'cat /etc/debian_version'"
REV=""
elif [ -f /etc/UnitedLinux-release ] ; then
DIST="${DIST}['cat /etc/UnitedLinux-release | tr "\n" ' ' | sed s/VERSION.*//']"
fi
OSSTR="${OS} ${DIST} ${REV}(${PSUEDONAME} ${KERNEL} ${MACH})"
fi
echo ${OSSTR}
No moderno Fedora e Debian (e Arch, CentOS, CoreOS, Mageia, openSUSE, Red Hat Enterprise Linux, SUSE Linux Enterprise Server, Ubuntu e outros) a maneira mais fácil é olhar para /etc/os-release ou executar hostnamectl status .
Em um script, você pode simplesmente fazer
#!/bin/sh
source /etc/os-release
echo $PRETTY_NAME
É claro, se você precisar identificar versões antigas ou distribuições não-systemd, você pode simplesmente começar com o acima, mas se /etc/os-release não existir, vá para outras heurísticas.
Veja Detectando nome e versão de distribuição do Linux na Documentação de estouro de pilha para mais.