web-dev-qa-db-fra.com

Comment obtenir la liste des paquets installés sans dépendances?

Software Center affiche en quelque sorte une liste assez courte de packages installés. Comment l'obtenir dans un fichier texte?

J'ai essayé:

> dpkg --get-selections|wc -l
3265

> aptitude search '~i!~M'|wc -l
1181

> dpkg -l | grep ^ii | sed 's_  _\t_g' | cut -f 2|wc -l
3076

> dpkg --get-selections | grep -v deinstall|wc -l
3076

> apt-mark showmanual|wc -l
1181

Je sais que j'ai installé quelques dizaines de paquets, pas des milliers. Il me faut dans la liste exactement les paquets que j'avais choisis sans dépendances pour le vérifier.

UPDATE

Merci beaucoup à @kos, j'ai finalement obtenu la liste avec cette commande:

> zcat /var/log/apt/history.log.*.gz | cat - /var/log/apt/history.log | grep -Po '^Commandline: apt-get install \K.*' | tr ' ' '\n' | grep -v '\-\-reinstall'|grep -v '\-\-force-yes'|grep -v '\-y'|grep -v '\-f'|sort|uniq wc -l
103
software-installationsoftware-center
7
zuba

Cela ne répond pas exactement à la question: il donne plutôt une commande pour lister toutes les commandes apt-get install jamais exécutées avec quelques conseils sur la manière d’analyser davantage la liste afin d’obtenir une liste de toutes les commandes. La commande apt-get install est exécutée, à l'exception de celles exécutées par Ubiquity, car la solution idéale pour cette tâche semble ne pas exister.

zcat /var/log/apt/history.log.*.gz | cat - /var/log/apt/history.log | grep -Po '^Commandline:(?= apt-get)(?=.* install ) \K.*'
  • zcat /var/log/apt/history.log.*.gz: décompresse tous les journaux apt compressés dans /var/log/apt, les concatène et les imprime dans stdout;
  • cat - /var/log/apt/history.log: ajoute /var/log/apt/history.log et imprime dans stdout;
  • grep -Po '^Commandline:(?= apt-get)(?=.* install ) \K.*': sélectionne uniquement les lignes commençant par Commandline: apt-get contenant install avec un espace pour le début et la fin, et affiche le reste de chaque ligne sélectionnée sur stdout;

Cela affichera la liste de toutes les commandes apt-get install jamais exécutées (la seule sortie indésirable pourrait être une commande apt-get-non -install mentionnant un paquet install, mais ce paquet n'existe pas (encore?), du moins dans les référentiels par défaut);

Remarque: Dans mon installation (Ubuntu 15.04 64 bits), les quatre premières commandes répertoriées sont celles exécutées par Ubiquity lors de l'installation. pour les exclure, vous pouvez diriger la sortie vers sed:

sed '1,4d'

Ainsi, la dernière commande approximative pour Ubuntu 15.04 64 bits serait:

zcat /var/log/apt/history.log.*.gz | cat - /var/log/apt/history.log | grep -Po '^Commandline:(?= apt-get)(?=.* install ) \K.*' | sed '1,4d'
11
kos
apt-mark showmanual

vous donnera une liste de tous les paquets installés manuellement sans les dépendances - la chose importante à noter est qu'il montrera également quels paquets ont été installés lors de l'installation d'Ubuntu.

Pour écrire la sortie dans un fichier:

apt-mark showmanual> un fichier

Il y a en réalité beaucoup d'autres manières, telles que l'utilisation de cette commande

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

Bien que je ne sache absolument pas comment cela fonctionne;)

Pour afficher les packages installés par date:

Les paquets installés par date utilisent cat /var/log/dpkg.log | grep "\ install\ > somefile"
Les paquets installés avec dpkg utilisent ls -l /var/log/dpkg* > somefile - celui-ci est probablement ce que vous recherchez.

Pour afficher les packages installés à l'aide de dpkg:

Ce fichier contient les informations ci-dessus: /var/log/dpkg.log

6
TellMeWhy

C'est en fait plus compliqué qu'il n'y paraît, et il y a pas mal de questions similaires sur Ask Ubuntu.

J'ai trouvé qu'en regardant dans /var/log/apt/history.log et dans les anciennes versions compressées de ce journal, tout ce qui est installé par une commande apt-get install est répertorié comme étant installé par cette commande.

Alors:

grep "apt-get install" /var/log/apt/history.log

Vous les montrera tous pendant la période couverte par l'historique d'apt actuel. Vous aurez besoin de gunzip vos anciens journaux et de les récupérer pour pouvoir rassembler toutes vos informations. Les commandes grep peuvent toutes être redirigées dans un fichier texte pour vous donner une liste de Nice.

Ceci n’est probablement utile que dans votre cas si Software Center utilise apt-get install lors de l’installation. Je sais que le centre de logiciel est un frontal pour apt mais je ne suis pas sûr qu'il utilise cette commande explicitement.

2
Arronical

Voici un script Ruby qui utilise rdepends pour vérifier si un package est une dépendance d'un autre package installé. Cela ne dira pas exactement ce que vous avez sélectionné, mais cela ne dépend pas de vos fichiers journaux (qui peuvent avoir été pivotés).

L'installation des packages répertoriés en tant que packages root installera tous les packages répertoriés dans les packages enfants. Donc, vous devriez vous retrouver avec presque (voir les inconvénients ci-dessous) la même liste de paquets.

La liste des enfants affichera les packages qui sont des dépendances d’autres packages enfants ou root.

Cette approche présente des inconvénients:

  • Certains paquets peuvent ne pas être listés en tant que root quand ils sont des dépendances de certains paquets recommandés facultatifs que vous avez sélectionnés Par exemple, sur mon serveur, Apache2 est répertorié dans les packages enfants, car j'ai également libapache2-mod-php, libapache2-mpm-itk et python-letsencrypt-Apache installé, qui ont Apache2 en tant que dépendance.
  • Les dépendances cycliques (les paquetages qui dépendent directement ou indirectement les uns des autres) seront listés dans les paquetages enfants (par exemple: libapache2-mod-php et libapache2-mod-php7.0). Il y a une section listant le cycle probable (vérifiez les ancêtres du paquet pour 5 générations), vous devriez l'inclure pour avoir la même liste de paquets (sauf si j'ai oublié autre chose).
#!/usr/bin/env Ruby

class ListRootPackages
  def run
    count = manual_marked_packages.count
    @dependencies ||= {}

    @root_packages ||= begin
      manual_marked_packages.each_with_index.map do |package, index|
        STDERR.print "   #{index + 1} / #{count} \r"

        intersection = manual_marked_packages & reverse_dependencies(package)

        if intersection.any?
          @dependencies[package] = intersection
          nil
        else
          package
        end
      end.compact
    end
  end

  def potential_cyclic_dependences
    run

    @potential_cyclic_dependences ||= @dependencies.keys.map do |package|
      package unless has_root_ancestor?(package, 5)
    end.compact
  end

  def has_root_ancestor?(package, level=0)
    return true if @root_packages.include?(package)
    return false if level.zero?

    @dependencies[package].any? { |parent| has_root_ancestor?(parent, level - 1) }
  end

  def root_packages
    run
    @root_packages
  end

  def dependencies
    run
    @dependencies
  end

  def manual_marked_packages
    @manual_marked_packages ||= parse_cli_list(`apt-mark showmanual`)
  end

  private

  def reverse_dependencies(package)
    parse_cli_list(`apt-cache rdepends #{package}`)[2..-1]
  end

  def parse_cli_list(list)
    list.split("\n").map(&:strip)
  end
end

list = ListRootPackages.new
list.run

puts "===== Root Packages (#{list.root_packages.count}) ====="
puts list.root_packages.join("\n")
puts

puts "===== Children packages (#{list.dependencies.count}) ====="
puts list.dependencies.map { |package, parents| "#{package}: #{parents.join(', ')}" }.join("\n")
puts

puts "===== Potential cyclic dependencies (#{list.potential_cyclic_dependences.count}) ====="
puts list.potential_cyclic_dependences.join(", ")

si quelqu'un veut convertir cela en Bash ou en Python, ce serait bien puisque Ruby est installé moins souvent sur des serveurs que Bash ou Python.

0
ybart