python/rpm/transaction.py

   1 #!/usr/bin/python
   2
   3 import rpm
   4 from rpm._rpm import ts as TransactionSetCore
   5
   6 # TODO: migrate relevant documentation from C-side
   7 class TransactionSet(TransactionSetCore):
   8     _probFilter = 0
   9
  10     def _wrapSetGet(self, attr, val):
  11         oval = getattr(self, attr)
  12         setattr(self, attr, val)
  13         return oval
  14
  15     def setVSFlags(self, flags):
  16         return self._wrapSetGet('_vsflags', flags)
  17
  18     def getVSFlags(self):
  19         return self._vsflags
  20
  21     def setColor(self, color):
  22         return self._wrapSetGet('_color', color)
  23
  24     def setPrefColor(self, color):
  25         return self._wrapSetGet('_prefcolor', color)
  26
  27     def setFlags(self, flags):
  28         return self._wrapSetGet('_flags', flags)
  29
  30     def setProbFilter(self, ignoreSet):
  31         return self._wrapSetGet('_probFilter', ignoreSet)
  32
  33     def parseSpec(self, specfile):
  34         import _rpmb
  35         return _rpmb.spec(specfile)
  36
  37     def getKeys(self):
  38         keys = []
  39         for te in self:
  40             keys.append(te.Key())
  41         # Backwards compatibility goo - WTH does this return a *tuple* ?!
  42         if not keys:
  43             return None
  44         else:
  45             return tuple(keys)
  46
  47     def addInstall(self, item, key, how="u"):
  48         if isinstance(item, basestring):
  49             f = file(item)
  50             header = self.hdrFromFdno(f)
  51             f.close()
  52         elif isinstance(item, file):
  53             header = self.hdrFromFdno(item)
  54         else:
  55             header = item
  56
  57         if not how in ['u', 'i']:
  58             raise ValueError('how argument must be "u" or "i"')
  59         upgrade = (how == "u")
  60
  61         if not TransactionSetCore.addInstall(self, header, key, upgrade):
  62             raise rpm.error("adding package to transaction failed")
  63
  64     def addErase(self, item):
  65         hdrs = []
  66         if isinstance(item, rpm.hdr):
  67             hdrs = [item]
  68         elif isinstance(item, rpm.mi):
  69             hdrs = item
  70         elif isinstance(item, int):
  71             hdrs = self.dbMatch(rpm.RPMDBI_PACKAGES, item)
  72         elif isinstance(item, basestring):
  73             hdrs = self.dbMatch(rpm.RPMDBI_LABEL, item)
  74         else:
  75             raise TypeError("invalid type %s" % type(item))
  76
  77         for h in hdrs:
  78             if not TransactionSetCore.addErase(self, h):
  79                 raise rpm.error("package not installed")
  80
  81         # garbage collection should take care but just in case...
  82         if isinstance(hdrs, rpm.mi):
  83             del hdrs
  84
  85     def run(self, callback, data):
  86         rc = TransactionSetCore.run(self, callback, data, self._probFilter)
  87
  88         # crazy backwards compatibility goo: None for ok, list of problems
  89         # if transaction didnt complete and empty list if it completed
  90         # with errors
  91         if rc == 0:
  92             return None
  93
  94         res = []
  95         if rc > 0:
  96             for prob in self.problems():
  97                 item = ("%s" % prob, (prob.type, prob._str, prob._num))
  98                 res.append(item)
  99         return res
 100
 101     def check(self, *args, **kwds):
 102         TransactionSetCore.check(self, *args, **kwds)
 103
 104         # compatibility: munge problem strings into dependency tuples of doom
 105         res = []
 106         for p in self.problems():
 107             # is it anything we need to care about?
 108             if p.type == rpm.RPMPROB_CONFLICT:
 109                 sense = rpm.RPMDEP_SENSE_CONFLICTS
 110             elif p.type == rpm.RPMPROB_REQUIRES:
 111                 sense = rpm.RPMDEP_SENSE_REQUIRES
 112             else:
 113                 continue
 114
 115             # strip arch, split to name, version, release
 116             nevr = p.altNEVR.rsplit('.', 1)[0]
 117             n, v, r = nevr.rsplit('-', 2)
 118
 119             # extract the dependency information
 120             needs = p._str.split()
 121             needname = needs[0]
 122             needflags = rpm.RPMSENSE_ANY
 123             if len(needs) == 3:
 124                 needop = needs[1]
 125                 if needop.find('<') >= 0: needflags |= rpm.RPMSENSE_LESS
 126                 if needop.find('=') >= 0: needflags |= rpm.RPMSENSE_EQUAL
 127                 if needop.find('>') >= 0: needflags |= rpm.RPMSENSE_GREATER
 128                 needver = needs[2]
 129             else:
 130                 needver = ""
 131
 132             res.append(((n, v, r),(needname,needver),needflags,sense,p.key))
 133
 134         return res
 135
 136     def hdrCheck(self, blob):
 137         res, msg = TransactionSetCore.hdrCheck(self, blob)
 138         # generate backwards compatibly broken exceptions
 139         if res == rpm.RPMRC_NOKEY:
 140             raise rpm.error("public key not available")
 141         elif res == rpm.RPMRC_NOTTRUSTED:
 142             raise rpm.error("public key not trusted")
 143         elif res != rpm.RPMRC_OK:
 144             raise rpm.error(msg)
 145
 146     def hdrFromFdno(self, fd):
 147         res, h = TransactionSetCore.hdrFromFdno(self, fd)
 148         # generate backwards compatibly broken exceptions
 149         if res == rpm.RPMRC_NOKEY:
 150             raise rpm.error("public key not available")
 151         elif res == rpm.RPMRC_NOTTRUSTED:
 152             raise rpm.error("public key not trusted")
 153         elif res != rpm.RPMRC_OK:
 154             raise rpm.error("error reading package header")
 155
 156         return h