#! /usr/bin/python -tt
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Library General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# Copyright 2005 Duke University
# Written by Seth Vidal
# TODOS: make all the package relationships deal with package objects
# search by package object for TransactionData, etc.
# provide a real TransactionData.remove(txmbr) method, It should
# remove the given txmbr and iterate to remove all those in depedent relationships
# with the given txmbr.
"""
Classes and functions for manipulating a transaction to be passed
to rpm.
"""
from constants import *
from packageSack import PackageSack, PackageSackVersion
from packages import YumInstalledPackage
from sqlitesack import YumAvailablePackageSqlite
import Errors
import warnings
import misc
import time
class GetProvReqOnlyPackageSack(PackageSack):
def __init__(self, need_files=False):
PackageSack.__init__(self)
self._need_index_files = need_files
def __addPackageToIndex_primary_files(self, obj):
for ftype in obj.returnFileTypes(primary_only=True):
for file in obj.returnFileEntries(ftype, primary_only=True):
self._addToDictAsList(self.filenames, file, obj)
def __addPackageToIndex_files(self, obj):
for ftype in obj.returnFileTypes():
for file in obj.returnFileEntries(ftype):
self._addToDictAsList(self.filenames, file, obj)
def _addPackageToIndex(self, obj):
for (n, fl, (e,v,r)) in obj.returnPrco('provides'):
self._addToDictAsList(self.provides, n, obj)
for (n, fl, (e,v,r)) in obj.returnPrco('requires'):
self._addToDictAsList(self.requires, n, obj)
if self._need_index_files:
self.__addPackageToIndex_files(obj)
else:
self.__addPackageToIndex_primary_files(obj)
def __buildFileIndexes(self):
for repoid in self.pkgsByRepo:
for obj in self.pkgsByRepo[repoid]:
self.__addPackageToIndex_files(obj)
def searchFiles(self, name):
if not self._need_index_files and not misc.re_primary_filename(name):
self._need_index_files = True
if self.indexesBuilt:
self.filenames = {}
self.__buildFileIndexes()
return PackageSack.searchFiles(self, name)
class TransactionData:
"""Data Structure designed to hold information on a yum Transaction Set"""
def __init__(self):
self.flags = []
self.vsflags = []
self.probFilterFlags = []
self.root = '/'
self.pkgdict = {} # key = pkgtup, val = list of TransactionMember obj
self._namedict = {} # name -> list of TransactionMember obj
self._unresolvedMembers = set()
self.debug = 0
self.changed = False
self.installonlypkgs = []
self.state_counter = 0
self.tm_created = time.time()
self.tm_changed = time.time()
self.conditionals = {} # key = pkgname, val = list of pos to add
self.rpmdb = None
self._pkgSack = None
self._pkgSackCtor = None
self.pkgSackPackages = 0
self.localSack = PackageSack()
self._inSack = GetProvReqOnlyPackageSack()
# lists of txmbrs in their states - just placeholders
self.instgroups = []
self.removedgroups = []
self.instenvironments = []
self.removedenvironments = []
self.removed = []
self.installed = []
self.updated = []
self.obsoleted = []
self.depremoved = []
self.depinstalled = []
self.depupdated = []
self.reinstalled = []
self.downgraded = []
self.failed = []
self._future_rpmdbv = None
self._check_future_rpmdbv = None
def _changed(self):
self.changed = True
self.state_counter += 1
self.tm_changed = time.time()
def __len__(self):
return len(self.pkgdict)
def __iter__(self):
if hasattr(self.getMembers(), '__iter__'):
return self.getMembers().__iter__()
else:
return iter(self.getMembers())
def _getPkgSack(self):
if self._pkgSack is not None:
return self._pkgSack
if self._pkgSackCtor is not None:
self._pkgSack = self._pkgSackCtor()
return self._pkgSack
pkgSack = property(fget=lambda self: self._getPkgSack(),
fset=lambda self, value: setattr(self, "_pkgSack",value),
fdel=lambda self: setattr(self, "_pkgSack", None),
doc="Package sack object")
def debugprint(self, msg):
if self.debug:
print msg
def getMembersWithState(self, pkgtup=None, output_states=None):
return filter(lambda p: p.output_state in output_states,
self.getMembers(pkgtup))
def getMembers(self, pkgtup=None):
"""takes an optional package tuple and returns all transaction members
matching, no pkgtup means it returns all transaction members"""
returnlist = []
if pkgtup is None:
for members in self.pkgdict.itervalues():
returnlist.extend(members)
elif pkgtup in self.pkgdict:
returnlist.extend(self.pkgdict[pkgtup])
return returnlist
# The order we resolve things in _matters_, so for sanity sort the list
# otherwise .i386 can be different to .x86_64 etc.
def getUnresolvedMembers(self):
return list(sorted(self._unresolvedMembers))
def markAsResolved(self, txmbr):
self._unresolvedMembers.discard(txmbr)
def resetResolved(self, hard=False):
if hard or len(self) < len(self._unresolvedMembers):
self._unresolvedMembers.clear()
self._unresolvedMembers.update(self.getMembers())
return True
return False
def getMode(self, name=None, arch=None, epoch=None, ver=None, rel=None):
"""returns the mode of the first match from the transaction set,
otherwise, returns None"""
txmbrs = self.matchNaevr(name=name, arch=arch, epoch=epoch, ver=ver, rel=rel)
if not len(txmbrs):
return None
states = []
for txmbr in txmbrs:
states.append(txmbr.ts_state)
if 'u' in states:
return 'u'
elif 'i' in states:
return 'i'
else:
return states[0]
def matchNaevr(self, name=None, arch=None, epoch=None, ver=None, rel=None):
"""returns the list of packages matching the args above"""
if name is None:
txmbrs = self.getMembers()
else:
txmbrs = self._namedict.get(name, [])
if arch is None and epoch is None and ver is None and rel is None:
return txmbrs[:]
result = []
for txmbr in txmbrs:
(n, a, e, v, r) = txmbr.pkgtup
# Name is done above
if arch is not None and arch != a:
continue
if epoch is not None and epoch != e:
continue
if ver is not None and ver != v:
continue
if rel is not None and rel != r:
continue
result.append(txmbr)
return result
def deselect(self, pattern):
""" Remove these packages from the transaction. This is more user
orientated than .remove(). Used from kickstart/install -blah. """
# We don't have a returnPackages() here, so just try the "simple"
# specifications. Pretty much 100% hit rate on kickstart.
txmbrs = self.matchNaevr(pattern)
if not txmbrs:
na = pattern.rsplit('.', 2)
if len(na) == 2:
txmbrs = self.matchNaevr(na[0], na[1])
if not txmbrs:
pkgs = []
if self._inSack is not None:
pkgs = self._inSack.returnPackages(patterns=[pattern])
if not pkgs and self.pkgSack is not None:
pkgs = self.pkgSack.returnPackages(patterns=[pattern])
if not pkgs:
pkgs = self.rpmdb.returnPackages(patterns=[pattern])
for pkg in pkgs:
txmbrs.extend(self.getMembers(pkg.pkgtup))
# Now we need to do conditional group packages, so they don't
# get added later on. This is hacky :(
for req, cpkgs in self.conditionals.iteritems():
if pkg in cpkgs:
cpkgs.remove(pkg)
self.conditionals[req] = cpkgs
for txmbr in txmbrs:
self.remove(txmbr.pkgtup)
return txmbrs
def _isLocalPackage(self, txmember):
# Is this the right criteria?
# FIXME: This is kinda weird, we really want all local pkgs to be in a
# special pkgsack before this point ... so that "yum up ./*.rpm" works.
# Also FakePackage() sets it off ... which is confusing and not what
# happens IRL.
return txmember.ts_state in ('u', 'i') and not isinstance(txmember.po, (YumInstalledPackage, YumAvailablePackageSqlite))
# NOTE: This is a copy of Depsolve.allowedMultipleInstalls() because
# we can't get to YumBase from here. Use that as the main/public API.
def _allowedMultipleInstalls(self, po):
"""takes a packageObject, returns 1 or 0 depending on if the package
should/can be installed multiple times with different vers
like kernels and kernel modules, for example"""
if po.name in self.installonlypkgs:
return True
provides = po.provides_names
if filter (lambda prov: prov in self.installonlypkgs, provides):
return True
return False
def add(self, txmember):
"""add a package to the transaction"""
for oldpo in txmember.updates:
self.addUpdated(oldpo, txmember.po)
if txmember.pkgtup not in self.pkgdict:
self.pkgdict[txmember.pkgtup] = []
else:
self.debugprint("Package: %s.%s - %s:%s-%s already in ts" % txmember.pkgtup)
for member in self.pkgdict[txmember.pkgtup]:
if member.ts_state == txmember.ts_state:
self.debugprint("Package in same mode, skipping.")
return
self.pkgdict[txmember.pkgtup].append(txmember)
self._namedict.setdefault(txmember.name, []).append(txmember)
self._changed()
if self._isLocalPackage(txmember):
self.localSack.addPackage(txmember.po)
elif isinstance(txmember.po, YumAvailablePackageSqlite):
self.pkgSackPackages += 1
if self._inSack is not None and txmember.output_state in TS_INSTALL_STATES:
if not txmember.po.have_fastReturnFileEntries():
# In theory we could keep this on if a "small" repo. fails
self._inSack = None
else:
self._inSack.addPackage(txmember.po)
if txmember.name in self.conditionals:
for pkg in self.conditionals[txmember.name]:
if self.rpmdb.contains(po=pkg):
continue
for condtxmbr in self.install_method(po=pkg):
condtxmbr.setAsDep(po=txmember.po)
self._unresolvedMembers.add(txmember)
def remove(self, pkgtup):
"""remove a package from the transaction"""
if pkgtup not in self.pkgdict:
self.debugprint("Package: %s not in ts" %(pkgtup,))
return
for txmbr in self.pkgdict[pkgtup]:
txmbr.po.state = None
if self._isLocalPackage(txmbr):
self.localSack.delPackage(txmbr.po)
elif isinstance(txmbr.po, YumAvailablePackageSqlite):
self.pkgSackPackages -= 1
if self._inSack is not None and txmbr.output_state in TS_INSTALL_STATES:
self._inSack.delPackage(txmbr.po)
self._namedict[txmbr.name].remove(txmbr)
self._unresolvedMembers.add(txmbr)
del self.pkgdict[pkgtup]
if not self._namedict[pkgtup[0]]:
del self._namedict[pkgtup[0]]
self._changed()
def exists(self, pkgtup):
"""tells if the pkg is in the class"""
if pkgtup in self.pkgdict:
if len(self.pkgdict[pkgtup]) != 0:
return 1
return 0
def isObsoleted(self, pkgtup):
"""true if the pkgtup is marked to be obsoleted"""
if self.exists(pkgtup):
for txmbr in self.getMembers(pkgtup=pkgtup):
if txmbr.output_state == TS_OBSOLETED:
return True
return False
def makelists(self, include_reinstall=False, include_downgrade=False):
"""returns lists of transaction Member objects based on mode:
updated, installed, erased, obsoleted, depupdated, depinstalled
deperased"""
self.instgroups = []
self.removedgroups = []
self.instenvironments = []
self.removedenvironments = []
self.removed = []
self.installed = []
self.updated = []
self.obsoleted = []
self.depremoved = []
self.depinstalled = []
self.depupdated = []
self.reinstalled = []
self.downgraded = []
self.failed = []
for txmbr in self.getMembers():
if txmbr.output_state == TS_UPDATE:
if txmbr.isDep:
self.depupdated.append(txmbr)
else:
self.updated.append(txmbr)
elif txmbr.output_state in (TS_INSTALL, TS_TRUEINSTALL):
if include_reinstall and txmbr.reinstall:
self.reinstalled.append(txmbr)
continue
if include_downgrade and txmbr.downgrades:
self.downgraded.append(txmbr)
continue
if txmbr.groups:
for g in txmbr.groups:
if g not in self.instgroups:
self.instgroups.append(g)
if txmbr.environments:
for evg in txmbr.environments:
if evg not in self.instenvironments:
self.instenvironments.append(evg)
# "user" here is kind of a hack ... we really shouldn't have
# .isDep == True, but this probably doesn't hurt.
if txmbr.isDep and txmbr.reason != 'user':
self.depinstalled.append(txmbr)
else:
self.installed.append(txmbr)
elif txmbr.output_state == TS_ERASE:
if include_downgrade and txmbr.downgraded_by:
continue
for g in txmbr.groups:
if g not in self.instgroups:
self.removedgroups.append(g)
for evg in txmbr.environments:
if evg not in self.instenvironments:
self.removedenvironments.append(evg)
if txmbr.isDep:
self.depremoved.append(txmbr)
else:
self.removed.append(txmbr)
elif txmbr.output_state == TS_OBSOLETED:
self.obsoleted.append(txmbr)
elif txmbr.output_state == TS_OBSOLETING:
self.installed.append(txmbr)
elif txmbr.output_state == TS_FAILED:
self.failed.append(txmbr)
else:
pass
self.updated.sort()
self.installed.sort()
self.removed.sort()
self.obsoleted.sort()
self.depupdated.sort()
self.depinstalled.sort()
self.depremoved.sort()
self.instgroups.sort()
self.removedgroups.sort()
self.instenvironments.sort()
self.removedenvironments.sort()
self.reinstalled.sort()
self.downgraded.sort()
self.failed.sort()
def addInstall(self, po):
"""adds a package as an install but in mode 'u' to the ts
takes a packages object and returns a TransactionMember Object"""
if self._allowedMultipleInstalls(po):
return self.addTrueInstall(po)
txmbr = TransactionMember(po)
txmbr.current_state = TS_AVAILABLE
txmbr.output_state = TS_INSTALL
txmbr.po.state = TS_INSTALL
txmbr.ts_state = 'u'
if self.rpmdb.contains(po=txmbr.po):
txmbr.reinstall = True
self.findObsoletedByThisMember(txmbr)
self.add(txmbr)
return txmbr
def addTrueInstall(self, po):
"""adds a package as an install
takes a packages object and returns a TransactionMember Object"""
txmbr = TransactionMember(po)
txmbr.current_state = TS_AVAILABLE
txmbr.output_state = TS_TRUEINSTALL
txmbr.po.state = TS_INSTALL
txmbr.ts_state = 'i'
if self.rpmdb.contains(po=txmbr.po):
txmbr.reinstall = True
self.add(txmbr)
return txmbr
def addErase(self, po):
"""adds a package as an erasure
takes a packages object and returns a TransactionMember Object"""
txmbr = TransactionMember(po)
txmbr.current_state = TS_INSTALL
txmbr.output_state = TS_ERASE
txmbr.po.state = TS_INSTALL
txmbr.ts_state = 'e'
self.add(txmbr)
return txmbr
def addUpdate(self, po, oldpo=None):
"""adds a package as an update
takes a packages object and returns a TransactionMember Object"""
if self._allowedMultipleInstalls(po):
return self.addTrueInstall(po)
txmbr = TransactionMember(po)
txmbr.current_state = TS_AVAILABLE
txmbr.output_state = TS_UPDATE
txmbr.po.state = TS_UPDATE
txmbr.ts_state = 'u'
if oldpo:
txmbr.relatedto.append((oldpo, 'updates'))
txmbr.updates.append(oldpo)
self.add(txmbr)
self.findObsoletedByThisMember(txmbr)
return txmbr
def addDowngrade(self, po, oldpo):
"""adds a package as an downgrade takes a packages object and returns
a pair of TransactionMember Objects"""
itxmbr = self.addErase(oldpo)
itxmbr.relatedto.append((po, 'downgradedby'))
itxmbr.downgraded_by.append(po)
atxmbr = self.addInstall(po)
if not atxmbr: # Fail?
self.remove(itxmbr.pkgtup)
return None
if 'reason' in oldpo.yumdb_info:
atxmbr.reason = oldpo.yumdb_info.reason
atxmbr.relatedto.append((oldpo, 'downgrades'))
atxmbr.downgrades.append(oldpo)
return (itxmbr, atxmbr)
def addUpdated(self, po, updating_po):
"""adds a package as being updated by another pkg
takes a packages object and returns a TransactionMember Object"""
txmbr = TransactionMember(po)
txmbr.current_state = TS_INSTALL
txmbr.output_state = TS_UPDATED
txmbr.po.state = TS_UPDATED
txmbr.ts_state = 'ud'
txmbr.relatedto.append((updating_po, 'updatedby'))
txmbr.updated_by.append(updating_po)
if 'reason' in po.yumdb_info: # Propbably worthless, but...
txmbr.reason = po.yumdb_info.reason
self.add(txmbr)
return txmbr
def addObsoleting(self, po, oldpo):
"""adds a package as an obsolete over another pkg
takes a packages object and returns a TransactionMember Object"""
txmbr = TransactionMember(po)
txmbr.current_state = TS_AVAILABLE
txmbr.output_state = TS_OBSOLETING
txmbr.po.state = TS_OBSOLETING
txmbr.ts_state = 'u'
txmbr.relatedto.append((oldpo, 'obsoletes'))
txmbr.obsoletes.append(oldpo)
if self.rpmdb.contains(po=txmbr.po):
txmbr.reinstall = True
self.add(txmbr)
return txmbr
def addObsoleted(self, po, obsoleting_po):
"""adds a package as being obsoleted by another pkg
takes a packages object and returns a TransactionMember Object"""
txmbr = TransactionMember(po)
txmbr.current_state = TS_INSTALL
txmbr.output_state = TS_OBSOLETED
txmbr.po.state = TS_OBSOLETED
txmbr.ts_state = 'od'
txmbr.relatedto.append((obsoleting_po, 'obsoletedby'))
txmbr.obsoleted_by.append(obsoleting_po)
if 'reason' in po.yumdb_info: # Propbably worthless, but...
txmbr.reason = po.yumdb_info.reason
self.add(txmbr)
for otxmbr in self.getMembersWithState(obsoleting_po.pkgtup,
[TS_OBSOLETING]):
if po in otxmbr.obsoletes:
continue
otxmbr.relatedto.append((po, 'obsoletes'))
otxmbr.obsoletes.append(po)
return txmbr
def setDatabases(self, rpmdb, pkgSack, pkgSackCtor=None):
self.rpmdb = rpmdb
self._pkgSack = pkgSack
self._pkgSackCtor = pkgSackCtor
def getNewProvides(self, name, flag=None, version=(None, None, None)):
"""return dict { packages -> list of matching provides }
searches in packages to be installed"""
result = { }
if not self.pkgSackPackages:
pass
elif self._inSack is None:
for pkg, hits in self.pkgSack.getProvides(name, flag, version).iteritems():
if self.getMembersWithState(pkg.pkgtup, TS_INSTALL_STATES):
result[pkg] = hits
else:
for pkg, hits in self._inSack.getProvides(name, flag, version).iteritems():
result[pkg] = hits
result.update(self.localSack.getProvides(name, flag, version))
return result
def getOldProvides(self, name, flag=None, version=(None, None, None)):
"""return dict { packages -> list of matching provides }
searches in packages already installed and not going to be removed"""
result = { }
for pkg, hits in self.rpmdb.getProvides(name, flag, version).iteritems():
if not self.getMembersWithState(pkg.pkgtup, TS_REMOVE_STATES):
result[pkg] = hits
return result
def getProvides(self, name, flag=None, version=(None, None, None)):
"""return dict { packages -> list of matching provides }"""
result = self.getOldProvides(name, flag, version)
result.update(self.getNewProvides(name, flag, version))
return result
def getNewRequires(self, name, flag=None, version=(None, None, None)):
"""return dict { packages -> list of matching provides }
searches in packages to be installed"""
result = { }
if not self.pkgSackPackages:
pass
elif self._inSack is None:
for pkg, hits in self.pkgSack.getRequires(name, flag, version).iteritems():
if self.getMembersWithState(pkg.pkgtup, TS_INSTALL_STATES):
result[pkg] = hits
else:
for pkg, hits in self._inSack.getRequires(name, flag, version).iteritems():
result[pkg] = hits
result.update(self.localSack.getRequires(name, flag, version))
return result
def getOldRequires(self, name, flag=None, version=(None, None, None)):
"""return dict { packages -> list of matching provides }
searches in packages already installed and not going to be removed"""
result = { }
for pkg, hits in self.rpmdb.getRequires(name, flag, version).iteritems():
if not self.getMembersWithState(pkg.pkgtup, TS_REMOVE_STATES):
result[pkg] = hits
return result
def getRequires(self, name, flag=None, version=(None, None, None)):
"""return dict { packages -> list of matching provides }"""
result = self.getOldRequires(name, flag, version)
result.update(self.getNewRequires(name, flag, version))
return result
def futureRpmDBVersion(self):
""" Return a simple version for the future rpmdb. Works like
rpmdb.simpleVersion(main_only=True)[0], but for the state the rpmdb
will be in after the transaction. """
if self._future_rpmdbv is not None:
sc, ret = self._future_rpmdbv
if sc == self.state_counter:
return ret
pkgs = self.rpmdb.returnPackages()
_reinstalled_pkgtups = {}
for txmbr in self.getMembersWithState(None, TS_INSTALL_STATES):
# reinstalls have to use their "new" checksum data, in case it's
# different.
if txmbr.reinstall:
_reinstalled_pkgtups[txmbr.po.pkgtup] = txmbr.po
pkgs.append(txmbr.po)
self.rpmdb.preloadPackageChecksums()
main = PackageSackVersion()
pkg_checksum_tups = []
for pkg in sorted(pkgs):
if pkg.repoid != 'installed':
# Paste from PackageSackBase.simpleVersion()
csum = pkg.returnIdSum()
main.update(pkg, csum)
pkg_checksum_tups.append((pkg.pkgtup, csum))
continue
# Installed pkg, see if it's about to die
if self.getMembersWithState(pkg.pkgtup, TS_REMOVE_STATES):
continue
# ...or die and be risen again (Zombie!)
if pkg.pkgtup in _reinstalled_pkgtups:
continue
# Paste from rpmdb.simpleVersion()
ydbi = pkg.yumdb_info
csum = None
if 'checksum_type' in ydbi and 'checksum_data' in ydbi:
csum = (ydbi.checksum_type, ydbi.checksum_data)
# We need all the pkgtups, so we even save the ones without a
# checksum.
pkg_checksum_tups.append((pkg.pkgtup, csum))
main.update(pkg, csum)
self.rpmdb.transactionCachePackageChecksums(pkg_checksum_tups)
self._future_rpmdbv = (self.state_counter, main)
return main
def findObsoletedByThisMember(self, txmbr):
"""addObsoleted() pkgs for anything that this txmbr will obsolete"""
# this is mostly to keep us in-line with what will ACTUALLY happen
# when rpm hits the obsoletes, whether we added them or not
for obs_n in txmbr.po.obsoletes_names:
for pkg in self.rpmdb.searchNevra(name=obs_n):
if pkg.obsoletedBy([txmbr.po]):
self.addObsoleted(pkg, txmbr.po)
txmbr.output_state = TS_OBSOLETING
txmbr.po.state = TS_OBSOLETING
class ConditionalTransactionData(TransactionData):
"""A transaction data implementing conditional package addition"""
def __init__(self):
warnings.warn("ConditionalTransactionData will go away in a future "
"version of Yum.", Errors.YumFutureDeprecationWarning)
TransactionData.__init__(self)
class SortableTransactionData(TransactionData):
"""A transaction data implementing topological sort on it's members"""
def __init__(self):
# Cache of sort
self._sorted = []
# Current dependency path
self.path = []
# List of loops
self.loops = []
TransactionData.__init__(self)
def _visit(self, txmbr):
self.path.append(txmbr.name)
txmbr.sortColour = TX_GREY
for po in txmbr.depends_on:
vertex = self.getMembers(pkgtup=po.pkgtup)[0]
if vertex.sortColour == TX_GREY:
self._doLoop(vertex.name)
if vertex.sortColour == TX_WHITE:
self._visit(vertex)
txmbr.sortColour = TX_BLACK
self._sorted.insert(0, txmbr.pkgtup)
def _doLoop(self, name):
self.path.append(name)
loop = self.path[self.path.index(self.path[-1]):]
if len(loop) > 2:
self.loops.append(loop)
def add(self, txmember):
txmember.sortColour = TX_WHITE
TransactionData.add(self, txmember)
self._sorted = []
def remove(self, pkgtup):
TransactionData.remove(self, pkgtup)
self._sorted = []
def sort(self):
if self._sorted:
return self._sorted
self._sorted = []
# loop over all members
for txmbr in self.getMembers():
if txmbr.sortColour == TX_WHITE:
self.path = [ ]
self._visit(txmbr)
self._sorted.reverse()
return self._sorted
class TransactionMember:
"""Class to describe a Transaction Member (a pkg to be installed/
updated/erased)."""
def __init__(self, po):
# holders for data
self.po = po # package object
self.current_state = None # where the package currently is (repo, installed)
self.ts_state = None # what state to put it into in the transaction set
self.output_state = None # what state to list if printing it
self.isDep = 0
self.reason = 'user' # reason for it to be in the transaction set
self.process = None # I think this is used nowhere by nothing - skv 2010/11/03
self.relatedto = [] # ([relatedpkg, relationship)]
self.depends_on = []
self.obsoletes = []
self.obsoleted_by = []
self.updates = []
self.updated_by = []
self.downgrades = []
self.downgraded_by = []
self.reinstall = False
self.groups = [] # groups it's in
self.environments = [] # Env. groups it's in
self.repopkg = None # repo pkg "group" it was removed/installed by
self._poattr = ['pkgtup', 'repoid', 'name', 'arch', 'epoch', 'version',
'release']
for attr in self._poattr:
val = getattr(self.po, attr)
setattr(self, attr, val)
if po.repoid == 'installed':
# We want to load these so that we can auto hardlink in the same
# new values. Because of the hardlinks it should be really cheap
# to load them ... although it's still a minor hack.
po.yumdb_info.get('from_repo')
po.yumdb_info.get('releasever')
po.yumdb_info.get('changed_by')
def setAsDep(self, po=None, relonly=False):
"""sets the transaction member as a dependency and maps the dep into the
relationship list attribute"""
if not relonly:
self.isDep = 1
if po:
self.relatedto.append((po, 'dependson'))
self.depends_on.append(po)
def removeDep(self, po):
"""sets the transaction member as a dependency and maps the dep into the
relationship list attribute"""
nrelto = []
for data in self.relatedto:
if data[0] == po:
continue
nrelto.append(data)
self.relatedto = nrelto
ndepon = []
for data in self.depends_on:
if data == po:
continue
ndepon.append(data)
self.depends_on = ndepon
def __cmp__(self, other):
return cmp(self.po, other.po)
def __hash__(self):
return object.__hash__(self)
def __str__(self):
return "%s.%s %s:%s-%s - %s" % (self.name, self.arch, self.epoch,
self.version, self.release, self.ts_state)
def __repr__(self):
return "<%s : %s (%s)>" % (self.__class__.__name__, str(self),hex(id(self)))
def _dump(self):
msg = ["mbr: %s,%s,%s,%s,%s %s\n" %
(self.name, self.arch, self.epoch, self.version, self.release,
self.current_state),
" repo: %s\n" % self.po.repo.id,
" ts_state: %s\n" % self.ts_state,
" output_state: %s\n" % self.output_state,
" isDep: %s\n" % bool(self.isDep),
" reason: %s\n" % self.reason,
# " process: %s\n" % self.process,
" reinstall: %s\n" % bool(self.reinstall)]
if self.relatedto:
msg += [" relatedto:"]
for (po, rel) in self.relatedto:
pkgorigin = 'a'
if isinstance(po, YumInstalledPackage):
pkgorigin = 'i'
msg += [" %s,%s,%s,%s,%s@%s:%s" %
(po.name, po.arch, po.epoch, po.version, po.release,
pkgorigin, rel)]
msg += ["\n"]
for lst in ['depends_on', 'obsoletes', 'obsoleted_by', 'downgrades',
'downgraded_by', 'updates', 'updated_by']:
thislist = getattr(self, lst)
if thislist:
msg += [" %s:" % lst]
for po in thislist:
pkgorigin = 'a'
if isinstance(po, YumInstalledPackage):
pkgorigin = 'i'
msg += [" %s,%s,%s,%s,%s@%s" %
(po.name, po.arch, po.epoch, po.version,
po.release, pkgorigin)]
msg += ["\n"]
if self.groups:
msg += [" groups: %s\n" % ' '.join(self.groups)]
if self.environments:
msg += [" environments: %s\n" % ' '.join(self.environments)]
if self.repopkg:
msg += [" repopkg: %s\n" % self.repopkg]
return ''.join(msg)