Gerando lista de pacotes instalados manualmente e consultando pacotes individuais

Gostaria de obter uma lista de pacotes instalados manualmente por aptou aptitudee poder descobrir se um foobarpacote foi instalado manual ou automaticamente. Existe alguma maneira legal de fazer isso na linha de comando?

Você pode usar um desses dois one-liners. Ambos produzem exatamente a mesma saída na minha máquina e são mais precisos do que todas as soluções propostas até agora (6 de julho de 2014) nesta questão.

Usando apt-mark:

comm -23 <(apt-mark showmanual | sort -u) <(gzip -dc /var/log/installer/initial-status.gz | sed -n 's/^Package: //p' | sort -u)

Usando aptitude:

comm -23 <(aptitude search '~i !~M' -F '%p' | sed "s/ *$//" | sort -u) <(gzip -dc /var/log/installer/initial-status.gz | sed -n 's/^Package: //p' | sort -u)

Pouquíssimos pacotes ainda caem nas falhas, embora eu suspeite que eles sejam realmente instalados pelo usuário, logo após a instalação pela configuração da localização do idioma ou, por exemplo, pelo instalador do codec Totem. Além disso, as versões do cabeçalho linux também parecem se acumular, mesmo que eu tenha instalado apenas o metapacote não específico da versão. Exemplos:

libreoffice-help-en-gb
openoffice.org-hyphenation
gstreamer0.10-fluendo-mp3
linux-headers-3.13.0-29    

Como funciona:

1. Obtenha a lista de pacotes instalados manualmente. Por aptidão, o adicional sedremove os espaços em branco restantes no final da linha.
2. Obtenha a lista de pacotes instalados logo após uma nova instalação.
3. Compare os arquivos, apenas produza as linhas no arquivo 1 que não estão presentes no arquivo 2.

Outras possibilidades não funcionam tão bem:

• Usando o ubuntu-14.04-desktop-amd64.manifestarquivo ( aqui para Ubuntu 14.04) em vez de /var/log/installer/initial-status.gz. Mais pacotes são mostrados como instalados manualmente, mesmo que não sejam.
• Usando apt-mark showautovez de /var/log/installer/initial-status.gz. apt-markpor exemplo, não inclui o pacote xserver-xorg, enquanto o outro arquivo inclui.

Eu usei várias outras postagens do StackExchange como referência, no entanto, nenhuma funciona tão bem quanto a solução acima:

• aptidão + manifesto
• initial-status.gz + apt-mark showauto

Ambos listam mais pacotes que a solução acima.

EDIT: O que fazer se você atualizou de uma versão anterior:

Se você atualizou o Ubuntu de uma versão para a próxima, provavelmente precisará ajustar esse processo. Nesse caso, eu verificaria o arquivo de manifesto da versão mais recente (veja acima) além do arquivo initial-status.gz da versão atual. Você pode fazer isso facilmente adicionando outra comparação. Usar apenas o arquivo de manifesto não funcionará, pois o arquivo de manifesto infelizmente não contém tudo o que o arquivo initial_status.gz (verifiquei).

Nas versões mais recentes do pacote apt, há também o comando apt-mark

apt-mark showmanual

Para o Ubuntu 16.04, confira o arquivo de log /var/log/apt/history.log.

Por exemplo:

zgrep 'Commandline: apt' /var/log/apt/history.log /var/log/apt/history.log.*.gz

Não é perfeito, mas é muito bom em deixar claro exatamente o que eu instalei manualmente. Coloque um -B 1no grep para ver quando ele foi instalado.

Saída de exemplo

Commandline: apt install postgresql-9.5-plv8
Commandline: aptdaemon role='role-install-file' sender=':1.85'
Commandline: apt install task
Commandline: apt autoremove
Commandline: apt install atom
Commandline: apt upgrade
Commandline: apt-get install asciinema
Commandline: apt install iperf3
Commandline: apt upgrade
Commandline: apt-get install chromium-browser
Commandline: apt install joe cpanminus build-essential postgresql libdbd-pg-perl libcrypt-openssl-bignum-perl libcrypt-openssl-rsa-perl libio-socket-ssl-perl libnet-ssleay-perl libssl-dev
Commandline: aptdaemon role='role-commit-packages' sender=':1.2314'
Commandline: apt install git
Commandline: apt install sqlite
Commandline: apt install whois
Commandline: apt install libdbd-pg-perl
Commandline: apt install perl-doc
Commandline: apt upgrade

Não tenho certeza se isso pega aptitudeou não. Parece não pegar instalações do aplicativo de desktop Ubuntu Software.

apt-mark showauto | grep -iE '^foobar$' produzirá "foobar" se o pacote foi instalado automaticamente, nada diferente.

aptitude search '!~M ~i'listará os pacotes que não foram instalados automaticamente. É uma pena que o aptitude não faça parte da instalação padrão no Ubuntu Desktop a partir da 10.10.

O script a seguir imprimirá todos os pacotes que não estão configurados para instalação automática e, portanto, foram instalados manualmente:

#!/usr/bin/python

try:
    import apt_pkg
except ImportError:
    print "Error importing apt_pkg, is python-apt installed?"
    sys.exit(1)

apt_pkg.init()
STATE_FILE = apt_pkg.config.find_dir("Dir::State") + "extended_states"
auto = set()
tagfile = apt_pkg.TagFile(open(STATE_FILE))
while tagfile.step():
    pkgname = tagfile.section.get("Package")
    autoInst = tagfile.section.get("Auto-Installed")
    if not int(autoInst):
        auto.add(pkgname)
print "\n".join(sorted(auto))

é baseado em como o apt-mark imprime os pacotes instalados automaticamente.

Para obter uma lista de todos os pacotes (não instalados, instalados pelo usuário ou instalados por padrão em todos os PPAs), aptuse o seguinte método:

apt list [option]

As opções possíveis úteis para isso são:

--installed para exibir apenas os pacotes que estão instalados no sistema (em mais de 50.000)

--manual-installedpara listar os pacotes que foram explicitamente instalados por um comando, diretamente ou como dependências.

Como alternativa, você pode fazer:

apt list --manual-installed | grep -F \[installed\] para obter uma lista de pacotes que resultaram apenas de comandos do usuário e suas dependências e obter informações adicionais sobre eles, como versão e arquitetura suportadas (x86, x86_64, amd64, all etc.)

Como várias pessoas comentaram, o apt-mark showmanual parece um pouco complicado (e eu o relatei como bug 727799 ). Quando estou usando, na verdade, ele relata muitas coisas que nem sequer estão logadas / var / lib / apt / extended_states (onde isso deveria estar armazenado) e o apt-get não está registrando as coisas instaladas em / var / lib / apt / extended_states (apenas em / var / lib / dpkg / status). O script python do txwikinger acima chama diretamente de / var / lib / apt / extended_states, mas se você o estiver usando hoje, a sintaxe pode não funcionar (a minha apenas começou a gerar erros com o Kubuntu 13.10). A sintaxe atualizada é:

#!/usr/bin/python
import sys

try:
    import apt_pkg
except ImportError:
    print "Error importing apt_pkg, is python-apt installed?"
    sys.exit(1)

apt_pkg.init()
STATE_FILE = apt_pkg.config.find_dir("Dir::State") + "extended_states"
auto = set()
tagfile = apt_pkg.TagFile(open(STATE_FILE))
while tagfile.step():
    pkgname = tagfile.section.get("Package")
    autoInst = tagfile.section.get("Auto-Installed")
    if not int(autoInst):
        auto.add(pkgname)
print "\n".join(sorted(auto))

Para mim, essa era uma lista muito curta de 5 itens que também não parecem precisos.

Eu gostaria de dar uma solução GUI.

1. Abrir Synaptic Package Manager

2. Vamos para Status

3. Clique Installed (manual)

Ele fornecerá a lista de pacotes instalados manualmente pelo apt ou aptitude.

Infelizmente, não encontrei nenhuma opção Custom Filterspara descobrir se um foobarpacote foi instalado manual ou automaticamente.

Se o pacote estiver abaixo, Installedmas não abaixo Installed (manual), ele foi instalado automaticamente. Se o pacote estiver abaixo Installed (manual), ele foi instalado manualmente.

Se ninguém lhe der uma resposta agradável usando um comando apr-something, você poderá fazê-lo da maneira mais difícil . O Apt-get armazena suas informações em / var / lib / apt / extended_states. Qualquer arquivo instalado automaticamente será adicionado a esse arquivo. Se você instalar um pacote já neste arquivo manualmente, o pacote permanecerá nesse arquivo, mas com Instalação automática: 0 na segunda linha. Não é deletado.

Nota: Conforme o esperado, melhores respostas que provavelmente funcionarão se aparecerem alterações no posicionamento do arquivo. Eu mantenho o meu apenas no caso de as informações no local do arquivo serem úteis.

Depois de pesquisar muito, consegui montar esse script. Funciona bem para mim:

# List of all packages currently installed
current=$(dpkg -l | awk '{print $2}' | sort | uniq)

# List of all packages that were installed with the system
pre=$(gzip -dc /var/log/installer/initial-status.gz | sed -n 's/^Package: //p' | sort | uniq)

# List of packages that don't depend on any other package
manual=$(apt-mark showmanual | sort | uniq)

# (Current - Pre) ∩ (Manual)
packages=$(comm -12 <(comm -23 <(echo "$current") <(echo "$pre")) <(echo "$manual") )

for pack in $packages; do
    packname=$(echo $pack | cut -f 1 -d ":")
    desc=$(apt-cache search "^$packname$" | sed -E 's/.* - (.*)/\1/')
    date=$(date -r /var/lib/dpkg/info/$pack.list)

    echo "# $desc"
    echo "# $date"
    echo "sudo apt-get install $pack"
    echo -e ""
done

Como Li Lo disse, apt-mark showautovocê deve obter uma lista enorme de coisas instaladas automaticamente.

Agora, para mostrar as coisas que são instaladas manualmente, verifica-se que existe um adorável modificador de pesquisa simples para o aptitude. Mas você não quer fazer isso. Você quer escrever um enorme comando bash que faça alguma ciência do foguete.

Nota: Esta é mais uma ilustração de quão legal você ficará, liberando comandos massivos do bash para todos os seus amigos.

comm -3  <(dpkg-query --show -f '${Package} ${Status}\n' | \n
grep "install ok installed" | cut --delimiter=' ' -f 1) <(apt-mark showauto)

Eu quebrei em duas linhas para facilitar a leitura. O que isso faz?

• Primeiro, consultamos o dpkg para obter uma lista dos pacotes que estão instalados.
• Nós filtramos os que estão realmente instalados (não apenas a configuração residual)
• Cortamos o status
• Comparamos essa lista com a lista automatizada de apt-mark
• Nós arrasamos porque podemos.

Isso listará todos os pacotes instalados manualmente sem: dependências, pacotes desinstalados, pacotes instalados durante a instalação do sistema.

unopts() {
  in=`cat`
  echo "$in" | sed -r 's/ --[^ ]+//g;s/ -[^ ]+//g'
}

list() {
  cat '/var/log/apt/history.log' |
  grep --color=never -v '\-o APT::Status-Fd=4 \-o APT::Keep-Fds::=5 \-o APT::Keep-Fds::=6' |
  egrep --color=never "Commandline: apt-get.* $1" |
  sed -r "s/Commandline: apt-get//;s/ $1//" |
  unopts |
  tr ' ' '\n' |
  sed '/^$/d'
}

hapt() {
  tmp=`mktemp -d`
  installed=$tmp/installed
  deleted=$tmp/deleted
  dpkg=$tmp/dpkg
  list 'install' > $installed
  list '(remove|purge|autoremove)' > $deleted
  dpkg --get-selections |
  grep -v 'deinstall' |
  cut -f 1 > $dpkg
  while read package
  do
    sed -i "0,/$package/{//d;}" $installed
  done < $deleted
  while read package
  do
    if [ -z "`grep --color=never "^$package$" $dpkg`" ]
    then
      sed -i "0,/$package/{//d;}" $installed
    fi
  done < $installed
  cat $installed
  rm -r $tmp
}