Instalé un Ubuntu 10.10 simple en mi computadora e instalé algún software a través de apt-get. La semana pasada logré romper todo y comencé desde cero, y necesito reinstalar mi software. ¿Hay alguna forma de crear una lista con todos los paquetes que he instalado manualmente?

¿Para que me diera una lista como texlive, ...y no texlive, texlive-dep1, textlive-dep2, ...y todos los paquetes estándar eliminados?

Si de alguna manera pudiera averiguar qué programas de la instalación regular he eliminado, ¡eso también sería increíble!

Actualización 2015-05-23: ahora uso Ansible como gestión de configuración en mis sistemas. Allí especifico los paquetes a instalar. Esto sirve al objetivo, instalando todos los programas en un sistema nuevo, incluso mejor. Entonces, esta pregunta podría ser la entrada en una gestión de configuración ligera.

Con esta sugerencia, ¡supongo que su instalación anterior aún se iniciará!

Para replicar un conjunto de paquetes en otra máquina:

En el Sistema A, ejecute:

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

Mueva el my-selectionsarchivo al Sistema B.

En el Sistema B, ejecute:

dpkg --set-selections < my-selections

y entonces:

sudo apt-get dselect-upgrade

Nota importante: si ha instalado paquetes de repositorios y / o PPA no estándar, también querrá copiar /etc/apt/sources.listy el contenido del /etc/apt/sources.list.d/Sistema A al Sistema B antes de ejecutar la actualización.

También puede usar dpkgpara ver lo que ha eliminado (Nota: esto también incluirá paquetes que instaló y eliminó manualmente ):

dpkg --get-selections | grep deinstall

Puede ver sus resultados en el terminal o, por supuesto, redirigir a un archivo.

Este hilo de superuser.com ofrece esta solución:

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

Si sus registros de apt están en / var / log / apt, algo como esto debería funcionar:

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

O si desea deshacerse de parte de la basura repetitiva en la salida:

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

Puede usar apt-mark , pero recomiendo debfoster :

sudo apt-get install debfoster
sudo debfoster

Esto inspeccionará todos los paquetes instalados y descubrirá cuáles mantienen los otros 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:

A medida que responde "y" a cada pregunta (solo presione Enter para moverse rápidamente), debfoster recopilará la lista de paquetes y los escribirá línea por línea en un archivo. Por defecto esto es a las /var/lib/debfoster/keepers. Se parece a esto:

gnome-do
texlive-full
...

Configuro debfoster vía /etc/debfoster.confpara poner esta lista /etc/debfoster-keepersy rastrear el archivo con etckeeper para mantener el historial y las copias de seguridad. La respuesta aquí muestra cómo instalar una lista de paquetes desde un archivo de texto delimitado por nueva línea:

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

Tenga en cuenta una limitación aquí, los paquetes que purgó tienen un '-' delante de ellos. Por lo tanto, desea eliminar esas líneas antes de llamar a apt-mark.

Aunque el sitio web de debfoster dice que debfoster está en desuso en favor de la aptitud, prefiero la configuración rápida y simple de debfoster. Lo coloca en el centro de la base de datos de su paquete y le permite limpiar las cosas, haciendo que los paquetes automáticos y manuales sean más obvios.

Escriba "h" en el indicador de debfoster para explicar sus opciones. Tipo "?" para ver la descripción del paquete. El cómo hacerlo aquí podría ser útil.

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

Da todos los paquetes instalados manualmente (no paquetes del sistema, no dependencias). Por ejemplo se muestra build-essentialpero no gcc.

Para aquellos que prefieren usar las herramientas apt- *, hay una utilidad apt-mark que permite consultar y modificar el estado manual / automático.

apt-mark showmanual

También puede especificar el patrón para los paquetes que le interesan:

apt-mark showmanual qemu\*

Finalmente lo tengo ahora:

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"

Puedo extraer todo abriendo los archivos de registro en / var / log / apt /

Luego entro y filtro manualmente los paquetes de instalación de apt-get. Puede haber una manera de hacer esto programáticamente, pero no estoy al tanto.

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

de esta manera verá la lista de comandos ejecutados en el pasado.

Elimine el código grep si necesita más información:

less history.log

si el registro está comprimido (es decir, termina con gz)

gunzip <filename>

para cerrarlo nuevamente cuando haya terminado, puede hacer:

gzip <filename>

No vi ninguna solución aquí que funcione para mí, he instalado bastantes paquetes de deb con dpkg y faltaban algunos de los elementos que estaba buscando particularmente.

Un revestimiento bastante largo, pero conveniente para copiar y pegar sería:

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

El comando anterior guarda una lista de paquetes en un archivo en su directorio de trabajo actual llamado my-packages.

Explicación

Primero construí una lista de paquetes que componía la línea base de paquetes seleccionados durante la instalación.

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

Seguido de una larga lista de elementos instalados en general.

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

Luego comparé los dos archivos initialy installedenumeré solo los elementos únicos para instalar.

comm -23 installed initial > custom

A partir de ahí, quise filtrar las dependencias, aquí es donde este método puede perder algunos paquetes deseados, no es consciente de las dependencias que también están instaladas explícitamente.

Escribí una función bash rápida para acortar estos pasos en el procesamiento de estos elementos.

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

Después de eso, pasé cada línea de mi archivo customa esta función con xargs.

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

Una vez que tuve la larga lista de todas las dependencias posibles, (no estoy seguro de cada declaración posible), una vez más obtuve las líneas que eran exclusivas de un solo archivo.

comm -23 custom deps > manual

Y mi lista final de paquetes ahora está en un archivo llamado manualdisponible para que lo revise.

Alguien vinculado a https://unix.stackexchange.com/questions/3595/ubuntu-list-explicitly-installed-packages/3624#3624 que tiene una buena solución, pero no se comporta correctamente como el resultado de aptitude ha cambiado. Aquí hay una versión actualizada, basada en paquetes comparados actualmente instalados en comparación con 12.04 LTS. Necesitará aptitudeinstalar, ese es el ú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 el comando anterior en partes, este bit genera un paquete por línea de todo lo instalado en el sistema

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

Y esto descarga la lista de paquetes predeterminada y recorta la información redundante.

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

y commcompara los dos archivos y genera los paquetes que no están en la lista predeterminada.

comm -23 currentlyinstalled defaultinstalled

Utilice un archivo de manifiesto de distribución como conjunto de paquetes base. Ordene los resultados instalados manualmente en grupos de paquetes por arquitectura y sección, para que sea más fácil concentrarse en grupos de paquetes (tal vez no le interesen algunas secciones).

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

No encontré uno que fuera adecuado para mí, así que escribí un guión. Mediante el análisis de los contenidos de /var/log/apt/history.log* y / var / log / aptitude, luego se ordena por fecha y hora, lo que da como resultado dos listas, una se instala manualmente pkgs, otra se instala pero se eliminan los pkgs. Script con verificación de 'lista de apt'. una pequeña desviación, porque el uso de dpkg instaló y modificó la fuente de PPA.

Puse aquí, https://github.com/eexpress/eexp-bin/blob/master/self-installed-pkg.pl .

si alguien necesita probarlo, tal vez necesite modificar algún código, ya que mis archivos de registro están mezclados en chino e inglés (especialmente el formato de fecha y hora RFC2822), necesito tratarlo.

Creo que desea utilizar /var/log/apt/history.logy sus amigos para dar los cambios que se han realizado:

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

(Modificado de la fuente )

Le dará todos los paquetes que se han instalado en la línea de comandos utilizando una variación de apt-get install.

Obtiene los archivos comprimidos en el viejo history.logs los agrega con el actual history.logy pasa a través de grep, extrayendo líneas con apt [-get] install [y / o reinstall] y mostrando el resto de la línea (-o flag) que equivale a nombre (s) del paquete

Esto necesitará una pequeña modificación (por ejemplo, con sed) si desea solo los nombres de los paquetes en líneas separadas; Un ejercicio para el lector!

Vale la pena señalar que el administrador de paquetes sinápticos ( gksu synaptico kdesudo synaptic) en la sección "estado" tiene una lista de "instalado (manualmente)". Si marca la lista completa para su eliminación [¡no la aplique!], Debería poder guardar los cambios marcados y obtener una lista de paquetes de esa manera. Precaución: esto está bloqueado synapticpara mí (calculando presumiblemente la eliminación de dependencias).