python/rpm/transaction.py

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