Eu instalei um Ubuntu 10.10 simples no meu computador e instalei algum software via apt-get. Na semana passada, eu consegui quebrar tudo e comecei do zero e preciso reinstalar o software. Existe alguma maneira de criar uma lista com todos os pacotes que eu instalei manualmente?

Para que me desse uma lista como texlive, ...e não texlive, texlive-dep1, textlive-dep2, ...e todos os pacotes padrão removidos?

Se eu pudesse descobrir de alguma forma quais programas da instalação regular removi, isso também seria incrível!

Atualização 23/05/2015: Agora uso o Ansible como gerenciamento de configuração em meus sistemas. Lá eu especifico os pacotes a serem instalados. Isso serve à meta, instalando todos os programas em um sistema novo, ainda melhor. Portanto, essa pergunta pode ser a entrada em algum gerenciamento de configuração leve.

Com essa sugestão, estou assumindo que sua instalação antiga ainda será inicializada!

Para replicar um conjunto de pacotes em outra máquina:

No sistema A, execute:

dpkg --get-selections | grep -v deinstall > my-selections

Mova o my-selectionsarquivo para o Sistema B.

No sistema B, execute:

dpkg --set-selections < my-selections

e depois:

sudo apt-get dselect-upgrade

Nota importante: se você instalou pacotes de repositórios não padronizados e / ou PPAs, também desejará copiar /etc/apt/sources.liste o conteúdo /etc/apt/sources.list.d/do Sistema A para o Sistema B antes de executar a atualização.

Você também pode dpkgver o que removeu (NB: isso também inclui pacotes que você instalou e removeu manualmente ):

dpkg --get-selections | grep deinstall

Você pode ver seus resultados no terminal ou, é claro, redirecionar para um arquivo.

Este tópico do superuser.com fornece esta solução:

aptitude search '?installed ?not(?automatic)'

Se seus logs do apt estiverem em / var / log / apt, algo como isto deve funcionar:

gunzip -c /var/log/apt/history.log.*.gz | grep "apt-get install"

Ou se você quiser se livrar de alguns dos itens repetitivos indesejados na saída:

gunzip -c /var/log/apt/history.log.*.gz | grep "apt-get install" \
  | cut -f4- -d" " | sort | uniq

Você pode usar o apt-mark , mas eu recomendo o debfoster :

sudo apt-get install debfoster
sudo debfoster

Isso inspecionará todos os pacotes instalados e descobrirá quais estão mantendo os outros instalados:

texlive-full is keeping the following 161 packages installed:
  cm-super cm-super-minimal context doc-base dvipng feynmf
  fonts-gfs-artemisia fonts-gfs-baskerville fonts-gfs-bodoni-classic
  ...
Keep texlive-full? [Ynpsiuqx?], [H]elp:

Conforme você responde "y" a cada pergunta (basta pressionar Enter para mover-se rapidamente), o debfoster coletará a lista de pacotes e os escreverá linha por linha em um arquivo. Por padrão, isso é em /var/lib/debfoster/keepers. Se parece com isso:

gnome-do
texlive-full
...

Eu configurei o debfoster via /etc/debfoster.confpara colocar esta lista /etc/debfoster-keeperse acompanhar o arquivo com o etckeeper para manter o histórico e os backups. A resposta aqui mostra como instalar uma lista de pacotes a partir de um arquivo de texto delimitado por nova linha:

sudo apt-mark manual $(cat debfoster-keepers)

Observe uma limitação aqui, os pacotes que você limpou têm um '-' na frente deles. Então você deseja remover essas linhas antes de chamar apt-mark.

Mesmo que o site do debfoster diga que o debfoster foi preterido em favor do aptitude, eu prefiro a configuração rápida e simples do debfoster. Ele coloca você no meio do banco de dados de pacotes e permite que você limpe as coisas, tornando os pacotes automático e manual mais óbvios.

Digite "h" no prompt do debfoster para explicar suas opções. Tipo "?" para ver a descrição do pacote. O tutorial aqui pode ser útil.

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

Fornece todos os pacotes instalados manualmente (não pacotes do sistema, não dependências). Para exemplos, mostra, build-essentialmas não gcc.

Para aqueles que preferem usar as ferramentas apt- *, existe um utilitário apt-mark que permite consultar e modificar o estado manual / automático.

apt-mark showmanual

Você também pode especificar um padrão para os pacotes nos quais você está interessado:

apt-mark showmanual qemu\*

Finalmente entendi agora:

outfile="$(mktemp)"
pattern='(\[INSTALLIEREN\]|\[INSTALL\])'

if [[ -f "/var/log/aptitude.1.gz" ]]
then
        gunzip -c /var/log/aptitude.*.gz | grep -E "$pattern" | awk '{ print $2; }' > "$outfile"
fi

if [[ -f "/var/log/aptitude" ]]
then
        grep -E "$pattern" "/var/log/aptitude" | awk '{ print $2; }' >> "$outfile"
fi

sort "$outfile"
rm "$outfile"

Sou capaz de extrair tudo abrindo os arquivos de log em / var / log / apt /

Então eu entro e filtro manualmente os pacotes de instalação do apt-get. Pode haver uma maneira de fazer isso programaticamente, mas não estou ciente disso.

cd /var/log/apt
cat  history.log | grep Commandline

Dessa forma, você vê a lista de comandos executados no passado.

Remova o código grep se precisar de mais informações:

less history.log

se o log estiver compactado (ou seja, terminar com gz)

gunzip <filename>

para compactá-lo novamente quando terminar, você pode:

gzip <filename>

Não vi nenhuma solução aqui funcionando para mim, instalei alguns pacotes deb com o dpkg e alguns dos itens que estava procurando particularmente estavam ausentes.

Um forro bastante longo, mas conveniente para copiar e colar seria:

export DPKG_INITIAL=$(mktemp) DPKG_INSTALLED=$(mktemp) DPKG_CUSTOM=$(mktemp) DPKG_DEPS=$(mktemp) zgrep -E '^Package' /var/log/installer/initial-status.gz | awk '{ print $2 }' > $DPKG_INITIAL ; awk '$3 !~ /install|remove|purge/ { next } { gsub(/remove|purge/, "uninstall", $3) ; gsub(/:.+/, "", $4) ; a[$4]=$3 } END { for (p in a) { if (a[p] == "install") { print p } } }' /var/log/dpkg.log | sort -u > $DPKG_INSTALLED ; comm -23 installed initial > $DPKG_CUSTOM ; function rdep() { apt-cache rdepends $1 | tail -n +3 | sed -e 's/^ //' -e '/^ /d' | cut -d':' -f1 | sort -u; } ; echo "$(for i in $(cat custom) ; do rdep $i ; done)" | sort -u > $DPKG_DEPS ; comm -23 custom deps > my-packages ; rm $DPKG_INITIAL $DPKG_INSTALLED $DPKG_CUSTOM $DPKG_DEPS

O comando acima salva uma lista de pacotes em um arquivo no seu diretório de trabalho atual chamado my-packages.

Explicação

Primeiro criei uma lista de pacotes que compunham a linha de base dos pacotes selecionados durante a instalação.

zgrep -E '^Package' /var/log/installer/initial-status.gz | awk '{ print $2 }' > initial

Seguido por uma longa lista de itens instalados em geral.

awk '$3 !~ /install|remove|purge/ { next } { gsub(/remove|purge/, "uninstall", $3) ; gsub(/:.+/, "", $4) ; a[$4]=$3 } END { for (p in a) { if (a[p] == "install") { print p } } }' /var/log/dpkg.log | sort -u > installed

Em seguida, comparei os dois arquivos initiale installedliste apenas os itens exclusivos a serem instalados.

comm -23 installed initial > custom

A partir daí, eu queria filtrar as dependências; é neste ponto que esse método pode perder alguns pacotes desejados; ele desconhece as dependências que também são explicitamente instaladas.

Eu escrevi uma função rápida do bash para diminuir essas etapas no processamento desses itens.

function rdep() { apt-cache rdepends $1 | tail -n +3 | sed -e 's/^ //' -e '/^ /d' | cut -d':' -f1 | sort -u; }

Depois disso, passei cada linha do meu arquivo custompara esta função com xargs.

echo "$(for i in $(cat custom) ; do rdep $i ; done)" | sort -u > deps

Depois de ter a longa lista de todas as dependências possíveis (não tenho certeza de todas as declarações possíveis), obtive novamente as linhas que eram exclusivas para um único arquivo.

comm -23 custom deps > manual

E minha lista finalizada de pacotes agora está em um arquivo chamado manualdisponível para revisão.

Alguém vinculado a https://unix.stackexchange.com/questions/3595/ubuntu-list-explicitly-installed-packages/3624#3624 que possui uma boa solução, mas não se comporta corretamente como a saída do aptitude mudou. Aqui está uma versão atualizada, baseada nos pacotes atualmente instalados comparados ao 12.04 LTS. Você precisará aptitudeinstalado, esse é o único requisito.

aptitude search '~i !~M' -F '%p' | sort -u | tr -d ' ' > currentlyinstalled && wget -qO - http://mirror.pnl.gov/releases/precise/ubuntu-12.04.3-desktop-amd64.manifest | cut -f 1 | sort -u > defaultinstalled && comm -23 currentlyinstalled defaultinstalled

Para dividir o comando acima em partes, esse bit gera um pacote por linha de tudo o que está instalado no sistema

aptitude search '~i !~M' -F '%p' | sort -u | tr -d ' ' > currentlyinstalled

E isso baixa a lista de pacotes padrão e recolhe as informações redundantes.

wget -qO - http://mirror.pnl.gov/releases/precise/ubuntu-12.04.3-desktop-amd64.manifest | cut -f 1 | sort -u > defaultinstalled

e commcompara os dois arquivos e gera os pacotes que não estão na lista padrão.

comm -23 currentlyinstalled defaultinstalled

Use um arquivo de manifesto de distribuição como o conjunto de pacotes base. Classifique os resultados instalados manualmente em grupos de pacotes por arquitetura e seção, para que seja mais fácil se concentrar em grupos de pacotes (talvez você não se importe com algumas seções).

https://gist.github.com/darrenleeweber/8cc570ff402f19af7fa4

#!/bin/bash

manifest_url='http://releases.ubuntu.com/releases/trusty/ubuntu-14.04.3-desktop-amd64.manifest'
manifest_file=$(echo $manifest_url | sed -e 's#.*/##g')
if [ ! -e $manifest_file ]; then
    wget -q $manifest_url
fi
cat $manifest_file | cut -f1 | sort -u > default_installed.txt

aptitude search '~i !~M' -F '%p' --disable-columns | sort -u > currently_installed.txt

comm -23 currently_installed.txt default_installed.txt > manually_installed.txt

# sort the 'mannually_installed.txt' packages by architecture and section
mkdir -p package_files
while read p; do
    apt-cache show $p > info.txt
    arch=$(grep -m1 'Architecture: ' info.txt | sed -e 's/Architecture: //')
    section=$(grep -m1 'Section: ' info.txt | sed -e 's/Section: //' -e 's/\//_/g')
    file="${arch}_${section}_packages.txt"
    echo $p >> "package_files/$file"
done <manually_installed.txt

rm info.txt

#! /bin/sh
DEFAULT=`tempfile`
CURRENT=`tempfile`
cat /var/log/installer/initial-status.gz | gzip -d | grep '^Package:' | awk '{ print $2}' | sort -u > $DEFAULT
aptitude search '~i !~M' -F '%p' | sort -u | tr -d ' ' | awk '{ print $1}' > $CURRENT
comm -23 $CURRENT $DEFAULT
rm $DEFAULT
rm $CURRENT

Não encontrei um que fosse adequado para mim, então escrevi um roteiro. Analisando o conteúdo de /var/log/apt/history.log* e / var / log / aptitude, classifique por data e hora, resultando em duas listas: uma é a instalação manual dos pacotes, a outra é instalada, mas os pacotes são removidos. Script com verificação 'apt list'. um pequeno desvio, porque o uso do dpkg instalou e modificou a fonte PPA.

Coloquei aqui, https://github.com/eexpress/eexp-bin/blob/master/self-installed-pkg.pl .

se alguém precisar testá-lo, talvez precise modificar algum código, pois meus arquivos de log são misturados em chinês e inglês (especialmente formato de data e hora RFC2822), preciso lidar com isso.

Eu acho que você deseja usar /var/log/apt/history.loge seus amigos para dar as alterações que foram feitas:

zcat /var/log/apt/history.log.*.gz | cat - /var/log/apt/history.log | grep -Po '^Commandline: apt(?:-get)? install (?!.*--reinstall)\K.*'

(Modificado da fonte )

Fornecerá todos os pacotes que foram instalados na linha de comando usando uma variação de apt-get install.

Ele obtém os arquivos compactados nos antigos history.loge os adiciona com a corrente history.loge passa pelo grep, extraindo linhas com o apt [-get] install [e / ou reinstalar] e mostrando o restante da linha (sinalizador -o) que equivale ao nome (s) do pacote.

Isso precisará de um pouco de modificação (por exemplo, com sed) se você quiser apenas os nomes dos pacotes em linhas separadas; um exercício para o leitor!

Vale a pena notar que o gerenciador de pacotes sinápticos ( gksu synapticou kdesudo synaptic) na seção "status" possui uma lista "instalada (manualmente)". Se você marcar a lista inteira para remoção [não a aplique !!], poderá salvar as alterações marcadas e obter uma lista de pacotes dessa maneira. Cuidado: isso está bloqueado synapticpara mim (calculando as remoções de dependência presumivelmente).