J'ai installé un Ubuntu 10.10 standard sur mon ordinateur et quelques logiciels via apt-get. La semaine dernière, j’ai réussi à tout casser, à repartir de zéro et je dois réinstaller mon logiciel. Est-il possible de créer une liste avec tous les paquets que j'ai installés manuellement?

Pour qu'il me donne une liste comme texlive, ...et non texlive, texlive-dep1, textlive-dep2, ...et que tous les paquets standard soient supprimés?

Si je pouvais en quelque sorte déterminer quels programmes de l'installation standard que j'ai supprimés, ce serait génial aussi!

Mise à jour 2015-05-23: J'utilise maintenant Ansible comme gestion de la configuration sur mes systèmes. Là je spécifie les paquets à installer. Cela sert l'objectif, en installant tous les programmes sur un nouveau système, même mieux. Donc, cette question pourrait être l'entrée dans une gestion de configuration légère.

Avec cette suggestion, je suppose que votre ancienne installation va toujours démarrer!

Pour répliquer un ensemble de packages sur une autre machine:

Sur le système A, exécutez:

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

Déplacez le my-selectionsfichier sur System B.

Sur le système B, exécutez:

dpkg --set-selections < my-selections

puis:

sudo apt-get dselect-upgrade

Remarque importante: si vous avez installé des packages à partir de référentiels non standard et / ou de PPA, vous souhaiterez également copier /etc/apt/sources.listle contenu /etc/apt/sources.list.d/du système A vers le système B avant d'exécuter la mise à niveau.

Vous pouvez également dpkgvoir ce que vous avez supprimé (NB: cela inclura également les paquets que vous avez manuellement installés et supprimés):

dpkg --get-selections | grep deinstall

Vous pouvez voir vos résultats dans le terminal ou, bien sûr, rediriger vers un fichier.

Ce fil de superuser.com donne cette solution:

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

Si vos journaux apt sont dans / var / log / apt, quelque chose comme ceci devrait fonctionner:

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

Ou si vous souhaitez vous débarrasser de certaines des ordures répétitives de la sortie:

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

Vous pouvez utiliser apt-mark , mais je recommande debfoster :

sudo apt-get install debfoster
sudo debfoster

Cela va inspecter tous les paquets installés et déterminer quels sont ceux qui gardent les autres installés:

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:

Au fur et à mesure que vous répondez "y" à chaque question (appuyez simplement sur la touche Entrée pour passer rapidement), debfoster collectera la liste des paquets et les écrira ligne par ligne dans un fichier. Par défaut c'est à /var/lib/debfoster/keepers. Cela ressemble à ceci:

gnome-do
texlive-full
...

Je configure debfoster via /etc/debfoster.confpour mettre cette liste sur /etc/debfoster-keeperset suivre le fichier avec etckeeper pour conserver l’historique et les sauvegardes. La réponse ci - dessous montre comment installer une liste de paquets à partir d'un fichier texte délimité par une nouvelle ligne:

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

Notez une limitation ici, les paquets que vous avez purgés ont un '-' devant eux. Donc, vous voulez supprimer ces lignes avant d'appeler apt-mark.

Bien que le site Web de debfoster indique que debfoster est déconseillé au profit d'aptitude, je préfère la configuration rapide et simple de debfoster. Il vous place au milieu de votre base de données de paquets et vous permet de tout nettoyer, rendant les paquets automatiques et manuels plus évidents.

Tapez "h" à l'invite de debfoster pour expliquer vos options. Tapez "?" pour voir la description du paquet. La marche à suivre ici pourrait être utile.

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

Donne tous les paquets installés manuellement (pas les paquets système, pas les dépendances). Par exemple, cela montre build-essentialmais pas gcc.

Pour ceux qui préfèrent utiliser apt- * tools, un utilitaire apt-mark permet d'interroger et de modifier l'état manuel / automatique.

apt-mark showmanual

Vous pouvez également spécifier un modèle pour les paquets qui vous intéressent:

apt-mark showmanual qemu\*

Je l'ai enfin compris maintenant:

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"

Je peux tout extraire en ouvrant les fichiers journaux dans / var / log / apt /

Je vais ensuite filtrer manuellement les paquets apt-get install. Il y a peut-être un moyen de faire cela par programmation mais je ne le sais pas.

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

De cette façon, vous voyez la liste des commandes exécutées dans le passé.

Supprimez le code grep si vous avez besoin de plus d'informations:

less history.log

si le journal est compressé (finissez avec gz)

gunzip <filename>

pour le compresser à nouveau lorsque vous avez terminé, vous pouvez faire:

gzip <filename>

Je ne voyais aucune solution ici fonctionner, j’ai installé pas mal de paquets deb avec dpkg et quelques-uns des éléments que je recherchais particulièrement manquaient.

Une ligne assez longue, mais pratique pour copier et coller serait:

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

La commande ci-dessus enregistre une liste de packages dans un fichier de votre répertoire de travail actuel, nommé my-packages.

Explication

J'ai d'abord construit une liste de paquets qui composaient la ligne de base des paquets sélectionnés lors de l'installation.

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

Suivie d'une longue liste d'éléments installés en général.

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

J'ai ensuite comparé les deux fichiers initialet installedne répertorier que les éléments uniques à installer.

comm -23 installed initial > custom

À partir de là, je voulais filtrer les dépendances. C’est ici que cette méthode peut manquer certains paquets souhaités, elle n’ignore pas les dépendances qui sont également installées explicitement.

J'ai écrit une fonction rapide bash pour raccourcir cette étape du traitement de ces éléments.

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

Après cela, j'ai passé chaque ligne de mon fichier customdans cette fonction avec xargs.

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

Une fois que j'ai eu la longue liste de toutes les dépendances possibles (je ne suis pas sûr de toutes les déclarations possibles), j'ai à nouveau obtenu les lignes qui étaient uniques à un seul fichier.

comm -23 custom deps > manual

Et ma liste finie de paquets est maintenant dans un fichier nommé manualque je peux consulter.

Quelqu'un lié à https://unix.stackexchange.com/questions/3595/ubuntu-list-explicitly-installed-packages/3624#3624 qui offre une bonne solution, mais ne se comporte pas correctement comme le résultat d'aptitude a changé. Voici une version mise à jour, basée sur les packages actuellement installés comparés à 12.04 LTS. Vous aurez besoin d' aptitudeinstaller, c'est la seule exigence.

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

Pour décomposer la commande ci-dessus en plusieurs parties, ce bit génère un paquet par ligne de tout ce qui est installé sur le système.

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

Et cela télécharge la liste de paquets par défaut et recadre les informations redondantes.

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

et commcompare les deux fichiers et affiche les paquets qui ne figurent pas dans la liste par défaut.

comm -23 currentlyinstalled defaultinstalled

Utilisez un fichier manifeste de distribution comme jeu de packages de base. Triez les résultats manuellement installés en groupes de paquets par architecture et section, afin de vous concentrer plus facilement sur des groupes de paquets (peut-être que vous ne vous souciez pas de certaines sections).

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

Je n'en ai trouvé aucun qui me convienne, alors j'ai écrit un script. En analysant les contenus de /var/log/apt/history.log* et de / var / log / aptitude, puis triez par date-heure, ce qui donne deux listes, l’une est manuellement installée, une autre pkgs, mais elle est supprimée. Script avec vérification 'apt list'. un petit écart, car l'utilisation de dpkg installé et modifié source PPA.

Je mets ici, https://github.com/eexpress/eexp-bin/blob/master/self-installed-pkg.pl .

si quelqu'un a besoin de le tester, peut-être d'avoir besoin de modifier du code, car mes fichiers journaux sont mélangés en chinois et en anglais (spécialement au format date / heure RFC2822), j'ai besoin de m'en occuper.

Je pense que vous voulez utiliser /var/log/apt/history.loget ses amis pour donner les modifications qui ont été apportées:

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

(Modifié à partir de la source )

Vous donnera tous les paquets qui ont été installés sur la ligne de commande en utilisant une variante de apt-get install.

Il récupère les fichiers compressés dans l'ancien. Il history.logles ajoute au courant history.loget passe par grep, en extrayant les lignes avec apt [-get] install [et / ou réinstaller] et en affichant le reste de la ligne (indicateur -o), ce qui revient à nom du paquet.

Cela nécessitera un peu de modding (par exemple avec sed) si vous voulez juste les noms de paquets sur des lignes séparées; un exercice pour le lecteur!

Il est à noter que le gestionnaire de paquets synaptic ( gksu synapticou kdesudo synaptic) dans la section "statut" a une liste "installé (manuellement)". Si vous marquez toute la liste pour suppression [ne l'appliquez pas !!], vous devriez pouvoir sauvegarder les modifications marquées et obtenir une liste des paquets de cette façon. Attention: ceci est bloqué synapticpour moi (en calculant les suppressions de dépendance).