Ho installato un semplice Ubuntu 10.10 sul mio computer e installato alcuni software tramite apt-get. La scorsa settimana sono riuscito a rompere tutto, ho appena iniziato da zero e ho bisogno di reinstallare il mio software. C'è un modo per creare un elenco con tutti i pacchetti che ho installato manualmente?

In modo che mi darebbe un elenco come texlive, ...e non texlive, texlive-dep1, textlive-dep2, ...e tutti i pacchetti standard rimossi?

Se potessi in qualche modo capire quali programmi dalla normale installazione ho rimosso, sarebbe fantastico!

Aggiornamento 23/05/2015: ora utilizzo Ansible come gestione della configurazione sui miei sistemi. Lì specifico i pacchetti da installare. Questo serve l'obiettivo, installando tutti i programmi su un nuovo sistema, ancora meglio. Quindi questa domanda potrebbe essere l'ingresso in qualche gestione della configurazione leggera.

Con questo suggerimento, suppongo che la tua vecchia installazione si avvierà ancora!

Per replicare un set di pacchetti su un altro computer:

Sul sistema A, eseguire:

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

Sposta il my-selectionsfile nel Sistema B.

Sul sistema B, eseguire:

dpkg --set-selections < my-selections

e poi:

sudo apt-get dselect-upgrade

Nota importante: se sono stati installati pacchetti da repository e / o PPA non standard, sarà inoltre necessario copiare /etc/apt/sources.liste il contenuto /etc/apt/sources.list.d/da Sistema A a Sistema B prima di eseguire l'aggiornamento.

Puoi usare anche dpkgper vedere cosa hai rimosso (NB: questo includerà anche i pacchetti che hai installato e rimosso manualmente ):

dpkg --get-selections | grep deinstall

Puoi vedere i tuoi risultati nel terminale o, ovviamente, reindirizzare a un file.

Questo thread di superuser.com offre questa soluzione:

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

Se i log di apt sono in / var / log / apt, qualcosa del genere dovrebbe funzionare:

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

O se vuoi sbarazzarti di una parte della spazzatura ripetitiva nell'output:

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

È possibile utilizzare apt-mark , ma raccomando debfoster :

sudo apt-get install debfoster
sudo debfoster

Questo controllerà tutti i pacchetti installati e scoprirà quali mantengono installati gli altri:

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:

Quando rispondi "y" a ciascuna domanda (premi Invio per spostarti rapidamente), debfoster raccoglierà l'elenco dei pacchetti e li scriverà riga per riga in un file. Di default questo è a /var/lib/debfoster/keepers. Sembra così:

gnome-do
texlive-full
...

Configuro debfoster tramite /etc/debfoster.confper mettere questo elenco /etc/debfoster-keeperse tracciare il file con etckeeper per conservare cronologia e backup. La risposta qui mostra come installare un elenco di pacchetti da un file di testo delimitato da una nuova riga:

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

Nota una limitazione qui, i pacchetti che hai eliminato hanno un '-' davanti a loro. Quindi vuoi rimuovere quelle linee prima di chiamare apt-mark.

Anche se il sito Web del debfoster afferma che debfoster è deprecato a favore di aptitude, preferisco la configurazione rapida e semplice di debfoster. Ti mette al centro del database dei pacchetti e ti consente di ripulire le cose, rendendo più ovvi i pacchetti automatici e manuali .

Digitare "h" al prompt di debfoster per spiegare le opzioni. Genere "?" per vedere la descrizione del pacchetto. Il tutorial qui potrebbe essere utile.

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

Fornisce tutti i pacchetti installati manualmente (non i pacchetti di sistema, non le dipendenze). Ad esempio, mostra build-essentialma non gcc.

Per coloro che preferiscono utilizzare gli strumenti apt- *, esiste un'utilità apt-mark che consente sia l'interrogazione che la modifica dello stato manuale / automatico.

apt-mark showmanual

Puoi anche specificare un modello per i pacchetti che ti interessano:

apt-mark showmanual qemu\*

Finalmente ho capito ora:

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"

Sono in grado di estrarre tutto aprendo i file di registro in / var / log / apt /

Quindi entro e filtrare manualmente i pacchetti di installazione di apt-get. Potrebbe esserci un modo per farlo programmaticamente, ma non ne sono consapevole.

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

in questo modo viene visualizzato l'elenco dei comandi eseguiti in passato.

Rimuovi il codice grep se hai bisogno di ulteriori informazioni:

less history.log

se il registro è compresso (ovvero termina con gz)

gunzip <filename>

per comprimerlo nuovamente quando hai finito puoi fare:

gzip <filename>

Non ho visto nessuna soluzione funzionare per me, ho installato alcuni pacchetti deb con dpkg e mancavano alcuni degli elementi che stavo cercando in particolare.

Un liner piuttosto lungo, ma comodo da copiare e incollare sarebbe:

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

Il comando precedente salva un elenco di pacchetti in un file nella directory di lavoro corrente denominata my-packages.

Spiegazione

Ho prima creato un elenco di pacchetti che componevano la linea di base dei pacchetti selezionati durante l'installazione.

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

Seguito da un lungo elenco di elementi installati in generale.

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

Ho quindi confrontato i due file initialed installedelencare solo gli elementi univoci da installare.

comm -23 installed initial > custom

Da lì ho voluto filtrare le dipendenze, è qui che questo metodo può perdere alcuni pacchetti desiderati, non è a conoscenza delle dipendenze che sono anche esplicitamente installate.

Ho scritto una rapida funzione bash per abbreviare questi passaggi nell'elaborazione di questi elementi.

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

Successivamente ho passato ogni riga dal mio file customin questa funzione con xargs.

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

Una volta che ho avuto la lunga lista di tutte le possibili dipendenze, (non sono sicuro su ogni possibile affermazione), ho ancora una volta ottenuto le righe che erano uniche per un singolo file.

comm -23 custom deps > manual

E il mio elenco completo di pacchetti è ora in un file denominato manualdisponibile per la revisione.

Qualcuno collegato a https://unix.stackexchange.com/questions/3595/ubuntu-list-explicitly-installed-packages/3624#3624 che ha una buona soluzione, ma non si comporta correttamente come l'output di aptitude è cambiato. Ecco una versione aggiornata, basata su pacchetti attualmente installati rispetto a 12.04 LTS. Sarà necessario aptitudeinstallare, questo è l'unico 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

Per suddividere il comando sopra in parti, questo bit genera un pacchetto per riga di tutto ciò che è installato sul sistema

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

E questo scarica l'elenco dei pacchetti predefinito e ritaglia le informazioni ridondanti.

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

e commconfronta i due file e genera i pacchetti che non sono presenti nell'elenco predefinito.

comm -23 currentlyinstalled defaultinstalled

Utilizzare un file manifest di distribuzione come set di pacchetti di base. Ordinare i risultati installati manualmente in gruppi di pacchetti per architettura e sezione, in modo che sia più facile concentrarsi su gruppi di pacchetti (forse non ti interessano alcune sezioni).

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

Non ne ho trovato uno adatto a me, quindi ho scritto una sceneggiatura. Analizzando il contenuto di /var/log/apt/history.log* e / var / log / aptitude, quindi ordina per datetime, risultando in due elenchi, uno viene installato manualmente pkgs, l'altro viene installato ma rimosso pkgs. Script con verifica 'apt list'. una piccola deviazione, perché l'uso di dpkg ha installato e modificato la fonte PPA.

Ho messo qui, https://github.com/eexpress/eexp-bin/blob/master/self-installed-pkg.pl .

se qualcuno ha bisogno di testarlo, forse ho bisogno di modificare un po 'di codice, perché i miei file di registro sono mescolati in cinese e inglese (specialmente in formato datetime RFC2822), ho bisogno di occuparmene.

Penso che tu voglia usare /var/log/apt/history.loge i suoi amici per dare i cambiamenti che sono stati fatti:

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

(Modificato dalla fonte )

Ti darà tutti i pacchetti che sono stati installati dalla riga di comando usando una variante di apt-get install.

Ottiene i file zippati nella vecchia history.logs li aggiunge con la corrente history.loge passa attraverso grep, estraendo le linee con apt [-get] install [e / o reinstall] e mostrando il resto della linea (-o flag) che equivale al nome / i del pacchetto.

Questo richiederà un piccolo modding (ad es. Con sed) se vuoi solo i nomi dei pacchetti su righe separate; un esercizio per il lettore!

Vale la pena notare che il gestore di pacchetti sinaptici ( gksu synaptico kdesudo synaptic) nella sezione "stato" ha un elenco "installato (manualmente)". Se contrassegni l'intero elenco per la rimozione [non applicarlo !!] dovresti essere in grado di salvare le modifiche contrassegnate e ottenere un elenco di pacchetti in quel modo. Attenzione: questo synapticmi ha bloccato (calcolando presumibilmente le rimozioni di dipendenze).