Generazione di un elenco di pacchetti installati manualmente e interrogazione di singoli pacchetti

Mi piacerebbe avere un elenco di pacchetti installati manualmente da apto aptitudeed essere in grado di scoprire se un foobarpacchetto è stato installato manualmente o automaticamente. C'è un modo pulito per farlo dalla riga di comando?

È possibile utilizzare una di queste due linee singole. Entrambi producono lo stesso identico output sulla mia macchina e sono più precisi di tutte le soluzioni finora proposte (6 luglio 2014) in questa domanda.

Utilizzando apt-mark:

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

Utilizzando 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)

Pochissimi pacchetti cadono ancora nelle fessure, anche se sospetto che questi siano effettivamente installati dall'utente, subito dopo l'installazione tramite l'installazione della localizzazione della lingua o, ad esempio, tramite il programma di installazione del codec Totem. Inoltre, anche le versioni di intestazione linux sembrano accumularsi, anche se ho installato solo il metapacchetto non specifico della versione. Esempi:

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

Come funziona:

1. Ottieni l'elenco dei pacchetti installati manualmente. Per attitudine, lo sedspazio aggiuntivo rimuove gli spazi bianchi rimanenti alla fine della linea.
2. Ottieni l'elenco dei pacchetti installati subito dopo una nuova installazione.
3. Confronta i file, genera solo le righe nel file 1 che non sono presenti nel file 2.

Anche altre possibilità non funzionano:

• Utilizzo del ubuntu-14.04-desktop-amd64.manifestfile ( qui per Ubuntu 14.04) anziché /var/log/installer/initial-status.gz. Più pacchetti vengono mostrati come installati manualmente anche se non lo sono.
• Usando apt-mark showautoinvece di /var/log/installer/initial-status.gz. apt-markper esempio non include il pacchetto xserver-xorg, mentre l'altro file lo fa.

Ho usato vari altri post StackExchange come riferimenti, tuttavia nessuno funziona così come la soluzione sopra:

• attitudine + manifest
• initial-status.gz + apt-mark showauto

Entrambi elencano più pacchetti rispetto alla soluzione sopra.

EDIT: cosa fare se hai effettuato l'aggiornamento da una versione precedente:

Se hai aggiornato Ubuntu da una versione all'altra, probabilmente dovrai adattare questo processo. In tal caso, verificherei il file manifest della versione più recente (vedere sopra) oltre al file iniziale-status.gz della versione corrente. Puoi farlo facilmente semplicemente aggiungendo un altro confronto. L'uso del solo file manifest non funzionerà, poiché il file manifest purtroppo non contiene tutto ciò che fa il file initial_status.gz (ho controllato).

Nelle versioni più recenti del pacchetto apt, c'è anche il comando apt-mark

apt-mark showmanual

Per Ubuntu 16.04, controlla il file di registro /var/log/apt/history.log.

Per esempio:

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

Non è perfetto, ma è abbastanza bravo a chiarire esattamente cosa ho installato a mano. Metti un -B 1grep per vedere quando è stato installato.

Esempio di output

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

Non sono sicuro se questo raccoglie aptitudeo no. Non sembra raccogliere installazioni dall'app desktop Ubuntu Software.

apt-mark showauto | grep -iE '^foobar$' produrrà "foobar" se il pacchetto è stato installato automaticamente, nient'altro.

aptitude search '!~M ~i'elencherà i pacchetti che non sono stati installati automaticamente. È un peccato che l'attitudine non farà parte dell'installazione predefinita su Ubuntu Desktop a partire dalla 10.10.

Il seguente script stamperà tutti i pacchetti che non sono impostati per l'installazione automatica e quindi sono stati installati 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))

si basa su come apt-mark stampa i pacchetti installati automaticamente.

Per ottenere un elenco di tutti i pacchetti (non installati, installati dall'utente o installati per impostazione predefinita, su tutti i PPA), aptutilizza il seguente metodo:

apt list [option]

Le possibili opzioni utili per questo sono:

--installed per visualizzare solo i pacchetti installati sul sistema (su circa 50.000+)

--manual-installedper elencare i pacchetti che sono stati esplicitamente installati da un comando, direttamente o come dipendenze.

In alternativa, potresti fare:

apt list --manual-installed | grep -F \[installed\] per ottenere un elenco di pacchetti risultanti solo dai comandi utente e dalle relative dipendenze e per ottenere informazioni aggiuntive su di essi come la versione e l'architettura supportate (x86, x86_64, amd64, all, ecc.)

Come diverse persone hanno commentato, lo showmanual di apt-mark sembra essere un po 'difettoso (e l'ho segnalato come bug 727799 ). Quando lo sto usando, in realtà riporta molte cose che non sono nemmeno registrate in / var / lib / apt / extended_states (dove si suppone che questo sia memorizzato) e apt-get non sta registrando le cose come installate in / var / lib / apt / extended_states (solo in / var / lib / dpkg / status). Lo script python di txwikinger sopra attinge direttamente da / var / lib / apt / extended_states ma se lo stai usando oggi la sintassi potrebbe non funzionare (la mia ha appena iniziato a generare errori con Kubuntu 13.10). La sintassi aggiornata è:

#!/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))

Per me questo era un elenco molto breve di 5 articoli che non sembra neanche accurato.

Vorrei dare una soluzione GUI.

1. Aperto Synaptic Package Manager

2. Vai a Status

3. Clic Installed (manual)

Fornirà l'elenco dei pacchetti installati manualmente da apt o aptitude.

Purtroppo non sono riuscito a trovare alcuna opzione Custom Filtersper scoprire se un foobarpacchetto è stato installato manualmente o automaticamente.

Se il pacchetto è sotto Installedma non sotto, Installed (manual)è stato installato automaticamente. Se il pacchetto è sotto, Installed (manual)è stato installato manualmente.

Se nessuno ti dà una bella risposta usando un comando apr-qualcosa puoi farlo nel modo più difficile . Apt-get memorizza le sue informazioni in / var / lib / apt / extended_states. Qualsiasi file installato automaticamente verrà aggiunto a questo file. Se installi un pacchetto già in questo file manualmente, il pacchetto rimarrà in questo file ma con Autoinstallato: 0 nella seconda riga. Non è cancellato

Nota: come previsto, risposte migliori che potrebbero funzionare se sono apparse modifiche al posizionamento dei file. Tengo il mio nel caso in cui le informazioni sulla posizione del file siano utili.

Dopo aver cercato su Google molto, sono riuscito a montare questo script. Funziona bene per me:

# 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

Come ha detto Li Lo, apt-mark showautodovresti procurarti un lungo elenco di cose installate automaticamente.

Ora per mostrare le cose che vengono installate manualmente, si scopre che c'è un adorabile semplice modificatore di ricerca per aptitude. Ma non vuoi farlo. Vuoi scrivere un enorme comando bash che fa un po 'di scienza missilistica.

Nota: questo è più un esempio di quanto apparirai figo lanciando enormi comandi bash a tutti i tuoi amici.

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

L'ho rotto su due righe per leggibilità. Cosa fa questo?

• Per prima cosa chiediamo a dpkg un elenco di pacchetti installati.
• Filtriamo quelli per quelli effettivamente installati (non solo configurazione residua)
• Tagliamo lo stato
• Confrontiamo tale elenco con l'elenco automatizzato di apt-mark
• Scuotiamo perché possiamo.

Verranno elencati tutti i pacchetti installati manualmente senza: dipendenze, pacchetti disinstallati, pacchetti installati durante l'installazione del 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
}