Verifique se um pacote apt-get está instalado e instale-o se não estiver no Linux

Estou trabalhando em um sistema Ubuntu e atualmente é o que estou fazendo:

if ! which command > /dev/null; then
   echo -e "Command not found! Install? (y/n) \c"
   read
   if "$REPLY" = "y"; then
      sudo apt-get install command
   fi
fi

É isso que a maioria das pessoas faria? Ou existe uma solução mais elegante?

Para verificar se packagenamefoi instalado, digite:

dpkg -s <packagename>

Você também pode usar um dpkg-queryque tenha uma saída mais limpa para o seu propósito e aceite curingas também.

dpkg-query -l <packagename>

Para descobrir qual pacote é o proprietário command, tente:

dpkg -S `which <command>`

Para obter mais detalhes, consulte o artigo Descubra se o pacote está instalado no Linux e no dpkg cheat sheet .

Para ser um pouco mais explícito, aqui está um script bash que verifica se há um pacote e o instala, se necessário. Obviamente, você pode fazer outras coisas ao descobrir que o pacote está ausente, como simplesmente sair com um código de erro.

REQUIRED_PKG="some-package"
PKG_OK=$(dpkg-query -W --showformat='${Status}\n' $REQUIRED_PKG|grep "install ok installed")
echo Checking for $REQUIRED_PKG: $PKG_OK
if [ "" = "$PKG_OK" ]; then
  echo "No $REQUIRED_PKG. Setting up $REQUIRED_PKG."
  sudo apt-get --yes install $REQUIRED_PKG 
fi

Se o script for executado em uma GUI (por exemplo, é um script do Nautilus), você provavelmente desejará substituir a chamada 'sudo' por uma chamada 'gksudo'.

Este one-liner retorna 1 (instalado) ou 0 (não instalado) para o pacote 'nano'.

$(dpkg-query -W -f='${Status}' nano 2>/dev/null | grep -c "ok installed")

mesmo que o pacote não exista / não esteja disponível.

O exemplo abaixo instala o pacote 'nano' se não estiver instalado.

if [ $(dpkg-query -W -f='${Status}' nano 2>/dev/null | grep -c "ok installed") -eq 0 ];
then
  apt-get install nano;
fi

dpkg -s uso programático com instalação automática

Gosto dpkg -sque ele saia com status 1se algum dos pacotes não estiver instalado, facilitando a automação:

pkgs='qemu-user pandoc'
if ! dpkg -s $pkgs >/dev/null 2>&1; then
  sudo apt-get install $pkgs
fi

man dpkg infelizmente não documenta o status de saída, mas acho que deve ser razoavelmente seguro confiar nele:

-s, --status package-name...
    Report status of specified package.

Uma coisa a notar é que executando:

sudo apt remove <package-name>

não remove necessariamente todos os arquivos imediatamente para alguns pacotes (mas remove outros, não sabe por quê?) e apenas marca o pacote para remoção.

Nesse estado, o pacote parece ainda ser utilizável e como seus arquivos ainda estão presentes, mas é marcado para remoção posteriormente.

Por exemplo, se você executar:

pkg=certbot

sudo apt install -y "$pkg"
dpkg -s "$pkg"
echo $?

sudo apt remove -y "$pkg"
dpkg -s "$pkg"
echo $?
ls -l /usr/lib/python3/dist-packages/certbot/reporter.py

sudo apt remove --purge certbot
dpkg -s "$pkg"
echo $?
ls -l /usr/lib/python3/dist-packages/certbot/reporter.py

então:

• as duas primeiras echo $?saídas 0, apenas a terceira produz1

• a saída para o primeiro dpkg -s certbotcontém:

  Status: deinstall ok installed

  enquanto o segundo diz:

  Status: deinstall ok config-files

  e só desaparece após a limpeza:

  dpkg-query: package 'certbot' is not installed and no information is available

• o arquivo /etc/logrotate.d/certbotainda está presente no sistema depois apt remove, mas não depois --purge.

  No entanto, o arquivo /usr/lib/python3/dist-packages/certbot/reporter.pyainda está presente mesmo depois --purge.

Eu não entendo o porquê, mas com o hellopacote o segundo dpkgdepois apt removemostra que ele já foi removido sem --purge:

dpkg-query: package 'hello' is not installed and no information is available

As documentações também não são claras, por exemplo:

sudo apt dselect-upgrade

não removeu certbotquando foi marcado como deinstall, embora man apt-getpareça indicar que:

dselect-upgradeé usado em conjunto com o front-end tradicional de empacotamento Debian, dselect (1). O dselect-upgrade segue as alterações feitas pelo dselect (1) no campo Status dos pacotes disponíveis e executa as ações necessárias para realizar esse estado (por exemplo, a remoção de antigos e a instalação de novos pacotes).

Veja também:

• /ubuntu/165951/dpkg-get-selections-shows-packages-marked-deinstall
• /ubuntu/423355/how-do-i-check-if-a-package-is-installed-on-my-server

Testado no Ubuntu 19.10.

aptPacote Python

Existe um pacote Python 3 pré-instalado chamado aptUbuntu 18.04 que expõe uma interface apt do Python!

Um script que verifica se um pacote está instalado e o instala se não puder pode ser visto em: Como instalar um pacote usando a API python-apt

Aqui está uma cópia para referência:

#!/usr/bin/env python
# aptinstall.py

import apt
import sys

pkg_name = "libjs-yui-doc"

cache = apt.cache.Cache()
cache.update()
cache.open()

pkg = cache[pkg_name]
if pkg.is_installed:
    print "{pkg_name} already installed".format(pkg_name=pkg_name)
else:
    pkg.mark_install()

    try:
        cache.commit()
    except Exception, arg:
        print >> sys.stderr, "Sorry, package installation failed [{err}]".format(err=str(arg))

Verifique se um executável está no PATHlugar

Consulte: Como posso verificar se existe um programa a partir de um script Bash?

Eu ofereço esta atualização, pois o Ubuntu adicionou seu "Personal Package Archive" (PPA) exatamente quando esta pergunta foi respondida, e os pacotes PPA têm um resultado diferente.

1. Pacote de repositório Debian nativo não instalado:

   ~$ dpkg-query -l apache-perl
   ~$ echo $?
   1

2. Pacote PPA registrado no host e instalado:

   ~$ dpkg-query -l libreoffice
   ~$ echo $?
   0

3. Pacote PPA registrado no host, mas não instalado:

   ~$ dpkg-query -l domy-ce
   ~$ echo $?
   0
   ~$ sudo apt-get remove domy-ce
   [sudo] password for user: 
   Reading package lists... Done
   Building dependency tree       
   Reading state information... Done
   Package domy-ce is not installed, so not removed
   0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.

Também publicado em: /superuser/427318/test-if-a-package-is-installed-in-apt/427898

UpAndAdam escreveu:

No entanto, você não pode simplesmente confiar nos códigos de retorno aqui para criar scripts

Na minha experiência, você pode confiar nos códigos de saída do dkpg.

O código de retorno do dpkg -s é 0 se o pacote estiver instalado e 1 se não estiver, então a solução mais simples que encontrei foi:

dpkg -s <pkg-name> 2>/dev/null >/dev/null || sudo apt-get -y install <pkg-name>

Funciona bem para mim ...

Isso parece funcionar muito bem.

$ sudo dpkg-query -l | grep <some_package_name> | wc -l

• Ele retorna 0se não estiver instalado ou algum número, > 0se instalado.

Eu decidi um baseado na resposta de Nultyi :

MISSING=$(dpkg --get-selections $PACKAGES 2>&1 | grep -v 'install$' | awk '{ print $6 }')
# Optional check here to skip bothering with apt-get if $MISSING is empty
sudo apt-get install $MISSING

Basicamente, a mensagem de erro de dpkg --get-selectionsé muito mais fácil de analisar do que a maioria das outras, porque não inclui status como "deinstall". Ele também pode verificar vários pacotes simultaneamente, algo que você não pode fazer apenas com códigos de erro.

Explicação / exemplo:

$ dpkg --get-selections  python3-venv python3-dev screen build-essential jq
dpkg: no packages found matching python3-venv
dpkg: no packages found matching python3-dev
screen                                          install
build-essential                                 install
dpkg: no packages found matching jq

Portanto, o grep remove os pacotes instalados da lista e o awk retira os nomes dos pacotes da mensagem de erro, resultando em MISSING='python3-venv python3-dev jq', que pode ser trivialmente inserido em um comando de instalação.

Não estou emitindo cegamente apt-get install $PACKAGESporque, como mencionado nos comentários, isso pode atualizar inesperadamente pacotes que você não estava planejando; não é realmente uma boa ideia para processos automatizados que se espera sejam estáveis.

Eu descobri que todas as soluções acima podem produzir um falso positivo se um pacote estiver instalado e, em seguida, removido, mas o pacote de instalação permanece no sistema.

Para replicar: Instalar pacote apt-get install curl
Remover pacoteapt-get remove curl

Agora teste as respostas acima.

O comando a seguir parece resolver essa condição:
dpkg-query -W -f='${Status}\n' curl | head -n1 | awk '{print $3;}' | grep -q '^installed$'

Isso resultará em uma instalação definitiva ou não instalada

Parece que hoje em dia apt-gethá uma opção --no-upgradeque apenas faz o que o OP deseja:

--no-upgradeNão atualize pacotes. Quando usado em conjunto com a instalação, o no-upgrade impedirá que os pacotes listados sejam atualizados se já estiverem instalados.

Página de manual de https://linux.die.net/man/8/apt-get

Portanto, você pode usar

apt-get install --no-upgrade package

e packageserá instalado apenas se não estiver.

$name="rsync"

[ `which $name` ] $$ echo "$name : installed" || sudo apt-get install -y $name

Isso fará isso. apt-get installé idempotente.

sudo apt-get install command

Usar:

apt-cache policy <package_name>

Se não estiver instalado, mostrará:

Installed: none

Caso contrário, ele mostrará:

Installed: version

Esse recurso já existe no Ubuntu e Debian, no command-not-foundpacote.

apt list [packagename]

parece ser a maneira mais simples de fazer isso fora do dpkg e das ferramentas apt- * mais antigas

which <command>
if [ $? == 1 ]; then
    <pkg-manager> -y install <command>
fi

Eu tinha um requisito semelhante ao executar o teste localmente, em vez de no docker. Basicamente, eu só queria instalar os arquivos .deb encontrados, se ainda não estavam instalados.

# If there are .deb files in the folder, then install them
if [ `ls -1 *.deb 2> /dev/null | wc -l` -gt 0 ]; then
  for file in *.deb; do
    # Only install if not already installed (non-zero exit code)
    dpkg -I ${file} | grep Package: | sed -r 's/ Package:\s+(.*)/\1/g' | xargs dpkg -s
    if [ $? != 0 ]; then
        dpkg -i ${file}
    fi;
  done;
else
  err "No .deb files found in '$PWD'"
fi

Eu acho que o único problema que vejo é que ele não verifica o número da versão do pacote, portanto, se o arquivo .deb for uma versão mais recente, isso não substituirá o pacote atualmente instalado.

Para o Ubuntu, o apt fornece uma maneira bastante decente de fazer isso. Abaixo está um exemplo para o google chrome:

apt -qq list google-chrome-stable 2>/dev/null | grep -qE "(installed|upgradeable)" || apt-get install google-chrome-stable

Estou redirecionando a saída de erro para null, porque o apt adverte contra o uso de seu "cli instável". Eu suspeito que o pacote da lista seja estável, então acho que não há problema em jogar esse aviso fora. O -qq torna o apt super silencioso.

Este comando é o mais memorável:

dpkg --get-selections <package-name>

Se estiver instalado, ele imprime:

instalação do <package-name>

Caso contrário, ele imprime

Não foram encontrados pacotes correspondentes ao <package-name>.

Isso foi testado no Ubuntu 12.04.1 (Precise Pangolin).

Muitas coisas foram ditas, mas para mim a maneira mais simples é:

dpkg -l | grep packagename

No Bash:

PKG="emacs"
dpkg-query -l $PKG > /dev/null || sudo apt install $PKG

Observe que você pode ter uma string com vários pacotes no PKG.

Eu uso da seguinte maneira:

which mySQL 2>&1|tee 1> /dev/null
  if [[ "$?" == 0 ]]; then
                echo -e "\e[42m MySQL already installed. Moving on...\e[0m"
        else
        sudo apt-get install -y mysql-server
                if [[ "$?" == 0 ]]; then
                        echo -e "\e[42mMy SQL installed\e[0m"
                else
                        echo -e "\e[42Installation failed\e[0m"
                fi
        fi