Generar una lista de paquetes instalados manualmente y consultar paquetes individuales

Me gustaría obtener una lista de paquetes instalados manualmente por apto aptitudey poder averiguar si un foobarpaquete se instaló manual o automáticamente. ¿Hay alguna forma ordenada de hacerlo desde la línea de comandos?

Puede usar cualquiera de estos dos one-liners. Ambos producen exactamente el mismo resultado en mi máquina y son más precisos que todas las soluciones propuestas hasta ahora (6 de julio de 2014) en esta pregunta.

Utilizando apt-mark:

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

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

Muy pocos paquetes aún caen en el olvido, aunque sospecho que estos son realmente instalados por el usuario, ya sea después de la instalación a través de la configuración de localización del idioma o, por ejemplo, a través del instalador de códec Totem. Además, las versiones de encabezado de Linux también parecen acumularse, aunque solo he instalado el metapaquete no específico de la versión. Ejemplos:

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

Como funciona:

1. Obtenga la lista de paquetes instalados manualmente. Por aptitud, el adicional sedelimina el espacio en blanco restante al final de la línea.
2. Obtenga la lista de paquetes instalados inmediatamente después de una nueva instalación.
3. Compare los archivos, solo muestre las líneas del archivo 1 que no están presentes en el archivo 2.

Otras posibilidades no funcionan tan bien:

• Usando el ubuntu-14.04-desktop-amd64.manifestarchivo ( aquí para Ubuntu 14.04) en lugar de /var/log/installer/initial-status.gz. Se muestran más paquetes como instalados manualmente aunque no lo sean.
• Usando en apt-mark showautolugar de /var/log/installer/initial-status.gz. apt-markpor ejemplo, no incluye el paquete xserver-xorg, mientras que el otro archivo sí.

Utilicé varias otras publicaciones de StackExchange como referencias, sin embargo, ninguna funciona tan bien como la solución anterior:

• aptitud + manifiesto
• initial-status.gz + apt-mark showauto

Ambos enumeran más paquetes que la solución anterior.

EDITAR: qué hacer si ha actualizado desde una versión anterior:

Si ha actualizado Ubuntu de una versión a la siguiente, probablemente necesitará ajustar este proceso. En ese caso, verificaría el archivo de manifiesto de la versión más reciente (ver arriba) además del archivo initial-status.gz de la versión actual. Puede hacerlo fácilmente simplemente agregando otra comparación. Usar solo el archivo de manifiesto no funcionará, ya que desafortunadamente el archivo de manifiesto no contiene todo lo que contiene el archivo initial_status.gz (lo comprobé).

En las versiones más recientes del paquete apt, también existe el comando apt-mark

apt-mark showmanual

Para Ubuntu 16.04, consulte el archivo de registro /var/log/apt/history.log.

Por ejemplo:

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

No es perfecto, pero es bastante bueno para dejar en claro exactamente lo que instalé a mano. Coloque un -B 1grep para ver cuándo se instaló.

Salida de ejemplo

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

No estoy seguro si esto se repite aptitudeo no. Parece que no recoge las instalaciones de la aplicación de escritorio Ubuntu Software.

apt-mark showauto | grep -iE '^foobar$' generará "foobar" si el paquete se instaló automáticamente, nada de lo contrario.

aptitude search '!~M ~i'enumerará los paquetes que no se instalaron automáticamente. Es una lástima que la aptitud no sea parte de la instalación predeterminada en Ubuntu Desktop a partir de 10.10.

El siguiente script imprimirá todos los paquetes que no están configurados para la instalación automática y, por lo tanto, se instalaron 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))

se basa en cómo apt-mark imprime los paquetes instalados automáticamente.

Para obtener una lista de todos los paquetes (no instalados, instalados por el usuario o instalados de manera predeterminada, en todos los PPA), aptutilice el siguiente método:

apt list [option]

Las posibles opciones útiles para esto son:

--installed para mostrar solo los paquetes que están instalados en el sistema (de más de 50,000+)

--manual-installedpara enumerar los paquetes que un comando instaló explícitamente , ya sea directamente o como dependencias.

Alternativamente, podrías hacer:

apt list --manual-installed | grep -F \[installed\] para obtener una lista de los paquetes que resultaron de los comandos del usuario y sus dependencias únicamente, y para obtener información adicional sobre ellos, como la versión y la arquitectura compatibles (x86, x86_64, amd64, todas, etc.)

Como varias personas han comentado, apt-mark showmanual parece estar un poco defectuoso (y lo informé como error 727799 ). Cuando lo estoy usando, en realidad informa muchas cosas que ni siquiera están conectadas / var / lib / apt / extended_states (donde se supone que está almacenado) y apt-get no está registrando cosas como instaladas en / var / lib / apt / extended_states (solo en / var / lib / dpkg / status). El script de Python de txwikinger anterior se basa directamente en / var / lib / apt / extended_states, pero si lo usa hoy, la sintaxis podría no funcionar (la mía acaba de comenzar a generar errores con Kubuntu 13.10). La sintaxis actualizada es:

#!/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 mí, esta fue una lista muy corta de 5 elementos que tampoco parece ser precisa.

Me gustaría dar una solución GUI.

1. Abierto Synaptic Package Manager

2. Ir Status

3. Hacer clic Installed (manual)

Le dará la lista de paquetes instalados manualmente por apt o aptitude.

Lamentablemente, no pude encontrar ninguna opción Custom Filterspara averiguar si un foobarpaquete se instaló manual o automáticamente.

Si el paquete está debajo Installedpero no debajo Installed (manual), se instaló automáticamente. Si el paquete está debajo Installed (manual), se instaló manualmente.

Si nadie le da una buena respuesta usando un comando apr-something, puede hacerlo de la manera difícil . Apt-get almacena su información en / var / lib / apt / extended_states. Cualquier archivo que se instale automáticamente se agregará a este archivo. Si instala un paquete que ya está en este archivo manualmente, el paquete permanecerá en este archivo pero con Instalación automática: 0 en la segunda línea. No está borrado.

Nota: Como se esperaba, mejores respuestas que probablemente funcionen si han aparecido cambios en la ubicación de los archivos. Mantengo la mía por si la información sobre la ubicación del archivo es útil.

Después de buscar mucho en Google, he logrado armar este script. Funciona bien para mí:

# 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 dijo Li Lo, apt-mark showautodebería obtener una gran lista de cosas instaladas automáticamente.

Ahora, para mostrar las cosas que se instalan manualmente, resulta que hay un modificador de búsqueda simple y encantador para la aptitud. Pero no quieres hacer eso. Desea escribir un gran comando bash que haga algo de ciencia espacial.

Nota: Esta es más una ilustración de lo genial que lucirás al eliminar comandos masivos de bash para todos tus amigos.

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

Lo partí en dos líneas para facilitar la lectura. ¿Qué hace esto?

• Primero consultamos dpkg para obtener una lista de los paquetes que están instalados.
• Los filtramos por los que están realmente instalados (no solo la configuración residual)
• Cortamos el estado
• Comparamos esa lista con la lista automatizada de apt-mark
• Nos balanceamos porque podemos.

Esto enumerará todos los paquetes instalados manualmente sin: dependencias, paquetes desinstalados, paquetes instalados durante la instalación 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
}