Interaktion mit YUM auf CentOS mit Python using

Was ist YUM?

YUM ist ein Verwaltungstool, das für RedHat- und CentOS-Linux-Distributionen verfügbar ist.  YUM (Yellowdog Updater Modified) ist von RPM-Paketen (Red Hat Package Manager) abhängig und wurde erstellt, um die Verwaltung von Paketen als Teile eines größeren Systems von Software-Repositorys anstelle einzelner Paketdateien zu ermöglichen. YUM ist ein interaktiver Paketmanager, der automatisch Abhängigkeitsanalysen und Systemaktualisierungen durchführen kann, zusammen mit der Installation neuer Pakete, dem Entfernen alter Pakete, dem Durchführen von Abfragen zu vorhandenen Paketen usw. Um mehr über YUM zu erfahren, klicken Sie auf Hier.

In diesem Artikel werden wir uns Methoden für den Zugriff auf die Yum-Funktionalität mit Python-Programmen ansehen und herausfinden, wie sie nützlich sein können. Für dieses Tutorial verwenden wir CENTOS 7 mit Python 2.7.x und würde eine gewisse Vertrautheit mit grundlegenden Python-Funktionen voraussetzen.

Programmieren mit YUM

Beginnen wir mit dem Programmieren von yum mit Python, indem wir uns ein einfaches Python-Skript ansehen, das yum verwendet, um Paketnamen abzufragen und zu drucken. Hier ist es:

Importieren von OS
Importsystem
Importieren Sie lecker
yb = lecker.YumBase()
yb.setCacheDir()
Ergebnisse = yb.pkgSack.returnNewestByNameArch(patterns=["python", "perl"])
für pkg in den Ergebnissen:
drucke "%s %s (%s) \n\t%s" % (pkg.Name, Packung.Version, Pkg.Bogen, Packung.Zusammenfassung)

Dieses Skript durchsucht die YUM-Repositorys nach Paketen, die dem Namen „python“ entsprechen, und gibt Informationen zu den übereinstimmenden Paketen aus. Wir werden dieses Skript Zeile für Zeile untersuchen.

Um mit der Programmierung mit YUM zu beginnen, müssen wir das Python-Paket 'yum' importieren - dieses ist standardmäßig in CENTOS 7 installiert. Zusammen mit 'yum' benötigen wir normalerweise auch die Pakete 'os' und 'sys' - also würde ein typisches Python-Programm, das yum verwendet, mit den folgenden 3 Zeilen beginnen.

Importieren von OS
Importsystem
Importieren Sie lecker

Um als Nächstes eine Yum-Instanz zu erstellen, mit der Sie arbeiten können, fügen Sie die folgende Zeile ein.

yb = lecker.YumBase()

Dies ist fast die erste Zeile funktionalen Codes in jedem Python-Programm, das yum verwendet. Dies liegt daran, dass YumBase die Basisklasse ist, die Methoden und Objekte enthält, die zum Ausführen aller Paketverwaltungsfunktionen mit yum erforderlich sind. Die detaillierte Struktur der YumBase-Klasse finden Sie in ihrer Dokumentation.

Überprüfen der YUM-Konfiguration

Sobald eine Instanz von YumBase verfügbar ist, können wir diese verwenden, um die Yum-Konfiguration zu überprüfen. Nachfolgend finden Sie eine Tabelle mit beliebten Befehlen zum Auflisten der Konfigurationsdetails.

Aufbau	Verwendung
yb . drucken.conf.config_file_path	Drucken Sie den Dateipfad für die Konfigurationsdatei von yum.
yb . drucken.conf.Logdatei	Um den Pfad der Logdatei auszudrucken
für ich in yb.conf.reposdir : drucken i	So drucken Sie die Verzeichnisse und Dateien für die Repositorys
yb . drucken.conf.skip_broken	Der Wert ist normalerweise falsch. Wenn sie auf "true" gesetzt ist, verhalten sich yum-Befehle so, als ob der Parameter -skip-broken angegeben wurde.
yb . drucken.conf.Fehlerlevel	So legen Sie die Fehlerstufe fest, die auf der Standardausgabe gedruckt werden soll. Es ist ein Wert zwischen 0-10, wobei 0 nur kritisch ist, während 10 alles ist, einschließlich Debug. Standardmäßig ist es auf 2 eingestellt, aber Sie können es überschreiben. Wenn Sie ein Skript ausführen, ist es eine gute Idee, dies auf 0 zu setzen. Sie können dies auf einen höheren Wert wie 3 setzen, wenn Sie das Skript selbst debuggen.

Pakete abfragen

Wenn wir zu unserem Skript zurückkehren, sehen wir, dass die nächste Codezeile ein neues Cache-Verzeichnis für yum einrichtet, damit es alle Aufgaben als normaler Benutzer ausführt (und bis zu einem gewissen Grad auch als Root-Benutzer - es kann immer noch keine Daten ändern). die yumdb oder rpmdb zum Beispiel).

yb.setCacheDir()

Nachdem wir jetzt ein echtes Yum-Objekt erstellt haben, können wir auf die Attribute pkgSack, rpmdb und repos zugreifen. Dadurch können wir folgende Funktionen ausführen:

yb.pkgSack - kann verwendet werden, um Abfragen für alle aktivierten Repositorys durchzuführen

yb.rpmdb - kann verwendet werden, um Abfragen der installierten Pakete durchzuführen

yb.repos - Holen Sie sich ein RepositoryStorage-Objekt, das verwendet werden kann, um bestimmte Konfigurationen für die Repositorys festzulegen und um Repositorys zu aktivieren oder zu deaktivieren - e.G., yb.repos.enableRepo(), yb.repos.disableRepo() & yb.repos.listEnabled(). Mehr dazu später.

Vorerst werden wir uns mit den Eigenschaften von pkgSack und rpmdb beschäftigen. Wir können die YUM-Repositorys bzw. die lokal installierten Pakete durchsuchen, indem wir eine der verschiedenen Funktionen aufrufen, die von den Attributen pkgSack und rpmdb bereitgestellt werden. Diese Funktionen geben „Paketobjekte“ zurück, die Informationen über das Paket enthalten. Einige nützliche Funktionen zum Abrufen der Paketobjekte sind: returnPackages(), searchPrimaryFields(), seachNevra(),  seachName() , returnNewestByNameArch(). Unser Skript verwendet die Methode returnNewstByNameArch, um die Paketobjekte abzurufen, die den Musterzeichenfolgen „python“ oder „perl“ entsprechen.

Beachten Sie, dass die Methodennamen für beide yb . gleich sind.rpmdb und yb.pkgSack. Sie führen die Abfragen jedoch auf verschiedenen Domänen durch - rpmdb durchsucht die lokal installierte RPM-Paketdatenbank, während pkgSack die YUM-Repositorys durchsucht.

Wir könnten auf ähnliche Weise die großen installierten Pakete auflisten (wobei groß bedeutet, dass die Größe > 10 MB ist). Der Yum-Code lautet:

plist = yb.rpmdb.returnPackages()
l_plist = [p für p in plist, wenn p.Größe > 1024 * 1024 * 10]
print "Installierte Pakete mit Größe > 10MB:"
für p in l_plist:
drucke "%s: %sMB" % (pkg, pkg.Größe / (1024 * 1024))

Das ist im Grunde die Essenz der Verwendung von Python, um auf Yum zuzugreifen. Im Rest des Artikels werden wir tiefer in die Nuancen der Yum-Modul-API eintauchen und einige kompliziertere Aktionen wie das Installieren / Deinstallieren von Paketen oder das Einrichten unseres eigenen Repositorys ausprobieren.

Nevra, PRCO und Tupel

Es gibt keinen Tippfehler in der Überschrift - dies sind einige yum-spezifische Begriffe, die es einfacher machen, Pakete und Abhängigkeiten zu identifizieren und diese mit anderen Benutzern von yum zu kommunizieren, einschließlich Ihrer Python-Skripte communicating.

NEVRA steht für Name, Epoch, Version, Release, Architecture und wird verwendet, um einen Flavor oder eine Instanz eines Pakets eindeutig zu identifizieren – diese fünf Parameter zusammen weisen eindeutig auf eine eindeutige Instanz des Pakets hin. Zum Beispiel kann ein Paket namens „python“ mehrere Versionen wie 2 . haben.6, 2.7 usw., und jede Version könnte mehrere Releases für verschiedene Architekturen haben, z.G., x86_64, i386 (Beachten Sie, dass sich das Wort Architektur hier auf die CPU-Architektur bezieht - e.G., i386 ist 32-Bit-Intel). Zusammen stellen diese fünf eine einzigartige Kombination dar und wird als Nevra . bezeichnet.

PRCO steht für Provides/Requires/Conflicts/Obsoletes, die die Paketverwaltungs-Metadaten für das Paketobjekt zusammenfassen.

Bestimmte API-Methoden in pkgSack/ rpmdb, wie yb.pkgSack.simplePkgList(), yb.pkgSack.PaketeByTuple() usw., NEVRA- oder PRCO-Informationen als Python-Tupel und nicht als pkgobjects zurückgeben

Pakete auflisten und installieren

Ähnlich wie bei der Verwendung des Befehls "yum list" können wir "yb" verwenden.doPackageLists()', um alle installierten Pakete/ Pakete aufzulisten, die für die Installation / Neuinstallation verfügbar sind.

plist = yb.doPackageLists(patterns=sys.argv[1:])

Jetzt enthält plist 3 Paketlisten - jeweils eine für das installierte Paket, das installierbare Paket und diejenigen, die für die Neuinstallation verfügbar sind. Wir können Pakete mit dem folgenden Code drucken/installieren/neu installieren:

wenn bitte.Eingerichtet:
"Installierte Pakete" drucken
für Pkg in sortiert (pl.Eingerichtet):
Pkg drucken
wenn bitte.verfügbar:
"Verfügbare Pakete" drucken
für Pkg in sortiert (pl.verfügbar):
Pkg drucken, Pkg.repo
wenn bitte.reinstall_verfügbar:
print "Verfügbare Pakete neu installieren"
für Pkg in sortiert (pl.reinstall_verfügbar):
Pkg drucken, Pkg.repo

Um alle installierten Pakete aufzulisten, die wir verwenden können:

drucke "\n".beitreten([x.Name für x in yb.rpmdb.returnPackages()])

Pakete installieren

Die Installation von Paketen umfasst das Einrichten und Ausführen einer Transaktion. Um einfache Aktionen wie Installieren/Entfernen auszuführen, verwenden wir das 'yb.install' oder 'yb.remove' bzw. um die Transaktion einzurichten. Dann rufen wir das 'yb . auf.solvDeps()' um die Auflösung von Abhängigkeiten auszulösen und 'yb.processTransaction()', um YUM anzuweisen, die Transaktion auszuführen.

Alle Schritte bis auf den letzten sind vorbereitend und erst der Aufruf der Methode processTransaction() führt tatsächlich zur Installation/Deinstallation. Unten ist ein Code-Snippet für die Paketinstallation.

yb = lecker.YumBase()
yb.install(name='Paketname')
yb.AuflöseDeps()
yb.processTransaction()

Bei der Durchführung solcher Transaktionen wird das 'yb.tsInfo'-Objekt enthält die Informationen über den aktuellen Status der Transaktion, bis sie festgeschrieben wird. Sie können mehr darüber in seiner Dokumentation lesen.

Richten Sie ein Repository an einem beliebigen Ort ein

Das folgende Skript hilft Ihnen, yum einzurichten, um auf ein Repository an einem beliebigen Ort zuzugreifen. Es erwartet, dass die URL des Repositorys als Befehlszeilenargument übergeben wird.

url = sys.argv[1]
yb = lecker.YumBase()
wenn nicht yb.setCacheDir(force=True, reuse=False):
drucken >>sys.stderr, "Kann kein tmp erstellen. Cachedir. "
sys.Ausgang(1)
yb.repos.disableRepo('*')
yb.add_enable_repo('myrepo', [url])

Um das Skript auszuführen

Python-Skript.py url://to/my/repo

Zusammenfassung

In diesem Artikel haben wir gelernt, wie man den YUM-Paketmanager mit seiner Python-API steuert. Wir haben uns die Konfigurationsoptionen sowie die Abfrage-/Such-APIs für die verfügbaren und installierten Pakete angesehen und schließlich Möglichkeiten zur Durchführung von Paketverwaltungsvorgängen wie das Installieren/Deinstallieren/Neuinstallieren von Paketen.

Dieser Artikel soll als Fenster zu dem dienen, was über die Yum Python API möglich ist. Obwohl die API nicht sehr gut dokumentiert ist, folgt sie Standardkonventionen und funktioniert vorhersehbar. Ausgestattet mit dem Wissen über die Fähigkeiten und Python-Fähigkeiten von YUM macht es Spaß, alles zu erkunden und zu lernen, was es kann. Ich hoffe, es hat Ihnen bis jetzt Spaß gemacht, zu lesen und dass Sie mit Ihrer Erforschung und Anwendung von Yum in Ihren Projekten fortfahren.