python/rpm/transaction.py.in

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