Edit File: history.py
#!/usr/bin/python -t # 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 2009 Red Hat # # James Antill <james@fedoraproject.org> import time import os, os.path import glob import re from weakref import proxy as weakref from sqlutils import sqlite, executeSQL, sql_esc_glob import yum.misc as misc import yum.constants from yum.constants import * from yum.packages import YumInstalledPackage, YumAvailablePackage, PackageObject from yum.i18n import to_unicode, to_utf8 from rpmUtils.arch import getBaseArch _history_dir = '/var/lib/yum/history' # NOTE: That we don't list TS_FAILED, because pkgs shouldn't go into the # transaction with that. And if they come out with that we don't want to # match them to anything anyway. _stcode2sttxt = {TS_UPDATE : 'Update', TS_UPDATED : 'Updated', TS_ERASE: 'Erase', TS_INSTALL: 'Install', TS_TRUEINSTALL : 'True-Install', TS_OBSOLETED: 'Obsoleted', TS_OBSOLETING: 'Obsoleting'} _sttxt2stcode = {'Update' : TS_UPDATE, 'Updated' : TS_UPDATED, 'Erase' : TS_ERASE, 'Install' : TS_INSTALL, 'True-Install' : TS_TRUEINSTALL, 'Dep-Install' : TS_INSTALL, 'Reinstall' : TS_INSTALL, # Broken 'Downgrade' : TS_INSTALL, # Broken 'Downgraded' : TS_INSTALL, # Broken 'Obsoleted' : TS_OBSOLETED, 'Obsoleting' : TS_OBSOLETING} # ---- horrible Copy and paste from sqlitesack ---- def _setupHistorySearchSQL(patterns=None, ignore_case=False): """Setup need_full and patterns for _yieldSQLDataList, also see if we can get away with just using searchNames(). """ if patterns is None: patterns = [] fields = ['name', 'sql_nameArch', 'sql_nameVerRelArch', 'sql_nameVer', 'sql_nameVerRel', 'sql_envra', 'sql_nevra'] need_full = False for pat in patterns: if yum.misc.re_full_search_needed(pat): need_full = True break pat_max = PATTERNS_MAX if not need_full: fields = ['name'] pat_max = PATTERNS_INDEXED_MAX if len(patterns) > pat_max: patterns = [] if ignore_case: patterns = sql_esc_glob(patterns) else: tmp = [] need_glob = False for pat in patterns: if misc.re_glob(pat): tmp.append((pat, 'glob')) need_glob = True else: tmp.append((pat, '=')) if not need_full and not need_glob and patterns: return (need_full, patterns, fields, True) patterns = tmp return (need_full, patterns, fields, False) # ---- horrible Copy and paste from sqlitesack ---- class _YumHistPackageYumDB: """ Class to pretend to be yumdb_info for history packages. """ def __init__(self, pkg): self._pkg = pkg _valid_yumdb_keys = set(["command_line", "from_repo", "from_repo_revision", "from_repo_timestamp", "installed_by", "changed_by", "reason", "releasever"]) def __getattr__(self, attr): """ Load yumdb attributes from the history sqlite. """ pkg = self._pkg if attr.startswith('_'): raise AttributeError, "%s has no yum attribute %s" % (pkg, attr) if attr not in self._valid_yumdb_keys: raise AttributeError, "%s has no yum attribute %s" % (pkg, attr) val = pkg._history._load_yumdb_key(pkg, attr) if False and val is None: raise AttributeError, "%s has no yum attribute %s" % (pkg, attr) if val is None: return None val = str(val) or "" setattr(self, attr, val) return val def __contains__(self, attr): # This is faster than __iter__ and it makes things fail in a much more # obvious way in weird FS corruption cases like: BZ 593436 x = self.get(attr) return x is not None def get(self, attr, default=None): """retrieve an add'l data obj""" try: res = getattr(self, attr) except AttributeError: return default return res class YumHistoryPackage(PackageObject): def __init__(self, name, arch, epoch, version, release, checksum=None, history=None): self.name = name self.version = version self.release = release self.epoch = epoch self.arch = arch self.pkgtup = (self.name, self.arch, self.epoch, self.version, self.release) if checksum is None: self._checksums = [] # (type, checksum, id(0,1) else: chk = checksum.split(':') self._checksums = [(chk[0], chk[1], 1)] # (type, checksum, id(0,1)) # Needed for equality comparisons in PackageObject self.repoid = "<history>" self._history = history self.yumdb_info = _YumHistPackageYumDB(self) _valid_rpmdb_keys = set(["buildtime", "buildhost", "license", "packager", "size", "sourcerpm", "url", "vendor", # ? "committer", "committime"]) def __getattr__(self, attr): """ Load rpmdb attributes from the history sqlite. """ if attr.startswith('_'): raise AttributeError, "%s has no attribute %s" % (self, attr) if attr not in self._valid_rpmdb_keys: raise AttributeError, "%s has no attribute %s" % (self, attr) val = self._history._load_rpmdb_key(self, attr) if False and val is None: raise AttributeError, "%s has no attribute %s" % (self, attr) if val is None: return None val = str(val) or "" setattr(self, attr, val) return val def _ui_from_repo(self): """ This reports the repo the package is from, we integrate YUMDB info. for RPM packages so a package from "fedora" that is installed has a ui_from_repo of "@fedora". Note that, esp. with the --releasever option, "fedora" or "rawhide" isn't authoritative. So we also check against the current releasever and if it is different we also print the YUMDB releasever. This means that installing from F12 fedora, while running F12, would report as "@fedora/13". """ if 'from_repo' in self.yumdb_info: self._history.releasever end = '' if (self._history.releasever is not None and 'releasever' in self.yumdb_info and self.yumdb_info.releasever != self._history.releasever): end = '/' + self.yumdb_info.releasever return '@' + self.yumdb_info.from_repo + end return self.repoid ui_from_repo = property(fget=lambda self: self._ui_from_repo()) class YumHistoryPackageState(YumHistoryPackage): def __init__(self, name,arch, epoch,version,release, state, checksum=None, history=None): YumHistoryPackage.__init__(self, name,arch, epoch,version,release, checksum, history) self.done = None self.state = state class YumHistoryRpmdbProblem: """ Class representing an rpmdb problem that existed at the time of the transaction. """ def __init__(self, history, rpid, problem, text): self._history = weakref(history) self.rpid = rpid self.problem = problem self.text = text self._loaded_P = None def __cmp__(self, other): if other is None: return 1 ret = cmp(self.problem, other.problem) if ret: return -ret ret = cmp(self.rpid, other.rpid) return ret def __hash__(self): return hash(self.rpid) def _getProbPkgs(self): if self._loaded_P is None: self._loaded_P = sorted(self._history._old_prob_pkgs(self.rpid)) return self._loaded_P packages = property(fget=lambda self: self._getProbPkgs()) class YumHistoryTransaction: """ Holder for a history transaction. """ def __init__(self, history, row): self._history = weakref(history) self.tid = row[0] self.beg_timestamp = row[1] self.beg_rpmdbversion = row[2] self.end_timestamp = row[3] self.end_rpmdbversion = row[4] self.loginuid = row[5] self.return_code = row[6] self._loaded_TW = None self._loaded_TD = None self._loaded_TS = None self._loaded_PROB = None self._have_loaded_CMD = False # cmdline can validly be None self._loaded_CMD = None self._loaded_ER = None self._loaded_OT = None self.altered_lt_rpmdb = None self.altered_gt_rpmdb = None def __cmp__(self, other): if other is None: return 1 ret = cmp(self.beg_timestamp, other.beg_timestamp) if ret: return -ret ret = cmp(self.end_timestamp, other.end_timestamp) if ret: return ret ret = cmp(self.tid, other.tid) return -ret def _getTransWith(self): if self._loaded_TW is None: self._loaded_TW = sorted(self._history._old_with_pkgs(self.tid)) return self._loaded_TW def _getTransData(self): if self._loaded_TD is None: self._loaded_TD = sorted(self._history._old_data_pkgs(self.tid)) return self._loaded_TD def _getTransSkip(self): if self._loaded_TS is None: self._loaded_TS = sorted(self._history._old_skip_pkgs(self.tid)) return self._loaded_TS trans_with = property(fget=lambda self: self._getTransWith()) trans_data = property(fget=lambda self: self._getTransData()) trans_skip = property(fget=lambda self: self._getTransSkip()) def _getProblems(self): if self._loaded_PROB is None: self._loaded_PROB = sorted(self._history._old_problems(self.tid)) return self._loaded_PROB rpmdb_problems = property(fget=lambda self: self._getProblems()) def _getCmdline(self): if not self._have_loaded_CMD: self._have_loaded_CMD = True self._loaded_CMD = self._history._old_cmdline(self.tid) return self._loaded_CMD cmdline = property(fget=lambda self: self._getCmdline()) def _getErrors(self): if self._loaded_ER is None: self._loaded_ER = self._history._load_errors(self.tid) return self._loaded_ER def _getOutput(self): if self._loaded_OT is None: self._loaded_OT = self._history._load_output(self.tid) return self._loaded_OT errors = property(fget=lambda self: self._getErrors()) output = property(fget=lambda self: self._getOutput()) class YumMergedHistoryTransaction(YumHistoryTransaction): def __init__(self, obj): self._merged_tids = set([obj.tid]) self._merged_objs = [obj] self.beg_timestamp = obj.beg_timestamp self.beg_rpmdbversion = obj.beg_rpmdbversion self.end_timestamp = obj.end_timestamp self.end_rpmdbversion = obj.end_rpmdbversion self._loaded_TW = None self._loaded_TD = None # Hack, this is difficult ... not sure if we want to list everything # that was skipped. Just those things which were skipped and then not # updated later ... or nothing. Nothing is much easier. self._loaded_TS = [] self._loaded_PROB = None self._have_loaded_CMD = False # cmdline can validly be None self._loaded_CMD = None self._loaded_ER = None self._loaded_OT = None self.altered_lt_rpmdb = None self.altered_gt_rpmdb = None def _getAllTids(self): return sorted(self._merged_tids) tid = property(fget=lambda self: self._getAllTids()) def _getLoginUIDs(self): ret = set((tid.loginuid for tid in self._merged_objs)) if len(ret) == 1: return list(ret)[0] return sorted(ret) loginuid = property(fget=lambda self: self._getLoginUIDs()) def _getReturnCodes(self): ret_codes = set((tid.return_code for tid in self._merged_objs)) if len(ret_codes) == 1 and 0 in ret_codes: return 0 if 0 in ret_codes: ret_codes.remove(0) return sorted(ret_codes) return_code = property(fget=lambda self: self._getReturnCodes()) def _getTransWith(self): ret = [] filt = set() for obj in self._merged_objs: for pkg in obj.trans_with: if pkg.pkgtup in filt: continue filt.add(pkg.pkgtup) ret.append(pkg) return sorted(ret) # This is the real tricky bit, we want to "merge" so that: # pkgA-1 => pkgA-2 # pkgA-2 => pkgA-3 # pkgB-1 => pkgB-2 # pkgB-2 => pkgB-1 # ...becomes: # pkgA-1 => pkgA-3 # pkgB-1 => pkgB-1 (reinstall) # ...note that we just give up if "impossible" things happen, Eg. # pkgA-1 => pkgA-2 # pkgA-4 => pkgA-5 @staticmethod def _p2sk(pkg, state=None): """ Take a pkg and return the key for it's state lookup. """ if state is None: state = pkg.state # Arch is needed so multilib. works, dito. getBaseArch() -- (so .i586 # => .i686 moves are seen) return (pkg.name, getBaseArch(pkg.arch), state) @staticmethod def _list2dict(pkgs): pkgtup2pkg = {} pkgstate2pkg = {} for pkg in pkgs: key = YumMergedHistoryTransaction._p2sk(pkg) pkgtup2pkg[pkg.pkgtup] = pkg pkgstate2pkg[key] = pkg return pkgtup2pkg, pkgstate2pkg @staticmethod def _conv_pkg_state(pkg, state): npkg = YumHistoryPackageState(pkg.name, pkg.arch, pkg.epoch,pkg.version,pkg.release, state, history=pkg._history) npkg._checksums = pkg._checksums npkg.done = pkg.done if _sttxt2stcode[npkg.state] in TS_INSTALL_STATES: npkg.state_installed = True if _sttxt2stcode[npkg.state] in TS_REMOVE_STATES: npkg.state_installed = False return npkg @staticmethod def _get_pkg(sk, pkgstate2pkg): if type(sk) != type((0,1)): sk = YumMergedHistoryTransaction._p2sk(sk) if sk not in pkgstate2pkg: return None return pkgstate2pkg[sk] def _move_pkg(self, sk, nstate, pkgtup2pkg, pkgstate2pkg): xpkg = self._get_pkg(sk, pkgstate2pkg) if xpkg is None: return del pkgstate2pkg[self._p2sk(xpkg)] xpkg = self._conv_pkg_state(xpkg, nstate) pkgtup2pkg[xpkg.pkgtup] = xpkg pkgstate2pkg[self._p2sk(xpkg)] = xpkg def _getTransData(self): def _get_pkg_f(sk): return self._get_pkg(sk, fpkgstate2pkg) def _get_pkg_n(sk): return self._get_pkg(sk, npkgstate2pkg) def _move_pkg_f(sk, nstate): self._move_pkg(sk, nstate, fpkgtup2pkg, fpkgstate2pkg) def _move_pkg_n(sk, nstate): self._move_pkg(sk, nstate, npkgtup2pkg, npkgstate2pkg) def _del1_n(pkg): del npkgtup2pkg[pkg.pkgtup] key = self._p2sk(pkg) if key in npkgstate2pkg: # For broken rpmdbv's and installonly del npkgstate2pkg[key] def _del1_f(pkg): del fpkgtup2pkg[pkg.pkgtup] key = self._p2sk(pkg) if key in fpkgstate2pkg: # For broken rpmdbv's and installonly del fpkgstate2pkg[key] def _del2(fpkg, npkg): assert fpkg.pkgtup == npkg.pkgtup _del1_f(fpkg) _del1_n(npkg) fpkgtup2pkg = {} fpkgstate2pkg = {} # We need to go from oldest to newest here, so we can see what happened # in the correct chronological order. for obj in self._merged_objs: npkgtup2pkg, npkgstate2pkg = self._list2dict(obj.trans_data) # Handle Erase => Install, as update/reinstall/downgrade for key in list(fpkgstate2pkg.keys()): (name, arch, state) = key if state not in ('Obsoleted', 'Erase'): continue fpkg = fpkgstate2pkg[key] for xstate in ('Install', 'True-Install', 'Dep-Install', 'Obsoleting'): npkg = _get_pkg_n(self._p2sk(fpkg, xstate)) if npkg is not None: break else: continue if False: pass elif fpkg > npkg: _move_pkg_f(fpkg, 'Downgraded') if xstate != 'Obsoleting': _move_pkg_n(npkg, 'Downgrade') elif fpkg < npkg: _move_pkg_f(fpkg, 'Updated') if xstate != 'Obsoleting': _move_pkg_n(npkg, 'Update') else: _del1_f(fpkg) if xstate != 'Obsoleting': _move_pkg_n(npkg, 'Reinstall') sametups = set(npkgtup2pkg.keys()).intersection(fpkgtup2pkg.keys()) for pkgtup in sametups: if pkgtup not in fpkgtup2pkg or pkgtup not in npkgtup2pkg: continue fpkg = fpkgtup2pkg[pkgtup] npkg = npkgtup2pkg[pkgtup] if False: pass elif fpkg.state == 'Reinstall': if npkg.state in ('Reinstall', 'Erase', 'Obsoleted', 'Downgraded', 'Updated'): _del1_f(fpkg) elif fpkg.state in ('Obsoleted', 'Erase'): # Should be covered by above loop which deals with # all goood state changes. good_states = ('Install', 'True-Install', 'Dep-Install', 'Obsoleting') assert npkg.state not in good_states elif fpkg.state in ('Install', 'True-Install', 'Dep-Install'): if False: pass elif npkg.state in ('Erase', 'Obsoleted'): _del2(fpkg, npkg) elif npkg.state == 'Updated': _del2(fpkg, npkg) # Move '*Install' state along to newer pkg. (not for # obsoletes). _move_pkg_n(self._p2sk(fpkg, 'Update'), fpkg.state) elif npkg.state == 'Downgraded': _del2(fpkg, npkg) # Move '*Install' state along to newer pkg. (not for # obsoletes). _move_pkg_n(self._p2sk(fpkg, 'Downgrade'), fpkg.state) elif fpkg.state in ('Downgrade', 'Update', 'Obsoleting'): if False: pass elif npkg.state == 'Reinstall': _del1_n(npkg) elif npkg.state in ('Erase', 'Obsoleted'): _del2(fpkg, npkg) # Move 'Erase'/'Obsoleted' state to orig. pkg. _move_pkg_f(self._p2sk(fpkg, 'Updated'), npkg.state) _move_pkg_f(self._p2sk(fpkg, 'Downgraded'), npkg.state) elif npkg.state in ('Downgraded', 'Updated'): xfpkg = _get_pkg_f(self._p2sk(fpkg, 'Updated')) if xfpkg is None: xfpkg = _get_pkg_f(self._p2sk(fpkg, 'Downgraded')) if xfpkg is None: if fpkg.state != 'Obsoleting': continue # Was an Install*/Reinstall with Obsoletes xfpkg = fpkg xnpkg = _get_pkg_n(self._p2sk(npkg, 'Update')) if xnpkg is None: xnpkg = _get_pkg_n(self._p2sk(npkg, 'Downgrade')) if xnpkg is None: xnpkg = _get_pkg_n(self._p2sk(npkg, 'Obsoleting')) if xnpkg is None: continue # Now we have 4 pkgs, f1, f2, n1, n2, and 3 pkgtups # f2.pkgtup == n1.pkgtup. So we need to find out if # f1 => n2 is an Update or a Downgrade. _del2(fpkg, npkg) if xfpkg == xnpkg: nfstate = 'Reinstall' if 'Obsoleting' in (fpkg.state, xnpkg.state): nfstate = 'Obsoleting' if xfpkg != fpkg: _move_pkg_f(xfpkg, nfstate) _del1_n(xnpkg) elif xfpkg < xnpkg: # Update... nfstate = 'Updated' nnstate = 'Update' if 'Obsoleting' in (fpkg.state, xnpkg.state): nnstate = 'Obsoleting' if xfpkg != fpkg: _move_pkg_f(xfpkg, nfstate) _move_pkg_n(xnpkg, nnstate) else: # Downgrade... nfstate = 'Downgraded' nnstate = 'Downgrade' if 'Obsoleting' in (fpkg.state, xnpkg.state): nnstate = 'Obsoleting' if xfpkg != fpkg: _move_pkg_f(xfpkg, nfstate) _move_pkg_n(xnpkg, nnstate) for x in npkgtup2pkg: fpkgtup2pkg[x] = npkgtup2pkg[x] for x in npkgstate2pkg: fpkgstate2pkg[x] = npkgstate2pkg[x] return sorted(fpkgtup2pkg.values()) def _getProblems(self): probs = set() for tid in self._merged_objs: for prob in tid.rpmdb_problems: probs.add(prob) return sorted(probs) def _getCmdline(self): cmdlines = [] for tid in self._merged_objs: if not tid.cmdline: continue if cmdlines and cmdlines[-1] == tid.cmdline: continue cmdlines.append(tid.cmdline) if not cmdlines: return None return cmdlines def _getErrors(self): ret = [] for obj in self._merged_objs: ret.extend(obj.errors) return ret def _getOutput(self): ret = [] for obj in self._merged_objs: ret.extend(obj.output) return ret def merge(self, obj): if obj.tid in self._merged_tids: return # Already done, signal an error? self._merged_tids.add(obj.tid) self._merged_objs.append(obj) # Oldest first... self._merged_objs.sort(reverse=True) if self.beg_timestamp > obj.beg_timestamp: self.beg_timestamp = obj.beg_timestamp self.beg_rpmdbversion = obj.beg_rpmdbversion if self.end_timestamp < obj.end_timestamp: self.end_timestamp = obj.end_timestamp self.end_rpmdbversion = obj.end_rpmdbversion class YumHistory: """ API for accessing the history sqlite data. """ def __init__(self, root='/', db_path=_history_dir, releasever=None): self._conn = None self.conf = yum.misc.GenericHolder() if not os.path.normpath(db_path).startswith(root): self.conf.db_path = os.path.normpath(root + '/' + db_path) else: self.conf.db_path = os.path.normpath('/' + db_path) self.conf.writable = False self.conf.readable = True self.releasever = releasever self._db_file = None if not os.path.exists(self.conf.db_path): try: os.makedirs(self.conf.db_path) except (IOError, OSError), e: # some sort of useful thing here? A warning? return self.conf.writable = True else: if os.access(self.conf.db_path, os.W_OK): self.conf.writable = True DBs = glob.glob('%s/history-*-*-*.sqlite' % self.conf.db_path) for d in reversed(sorted(DBs)): fname = os.path.basename(d) fname = fname[len("history-"):-len(".sqlite")] pieces = fname.split('-', 4) if len(pieces) != 3: continue try: map(int, pieces) except ValueError: continue self._db_date = '%s-%s-%s' % (pieces[0], pieces[1], pieces[2]) self._db_file = d break if self._db_file is None: if not self._create_db_file(): # Couldn't create a db file return # make an addon path for where we're going to stick # random additional history info - probably from plugins and what-not self.conf.addon_path = self.conf.db_path + '/' + self._db_date if not os.path.exists(self.conf.addon_path): try: os.makedirs(self.conf.addon_path) except (IOError, OSError), e: # some sort of useful thing here? A warning? return else: if os.access(self.conf.addon_path, os.W_OK): self.conf.writable = True def __del__(self): self.close() def _get_cursor(self): if self._conn is None: if not self.conf.readable: return None try: self._conn = sqlite.connect(self._db_file) except (sqlite.OperationalError, sqlite.DatabaseError): self.conf.readable = False return None # Note that this is required due to changing the history DB in the # callback for removed txmbrs ... which happens inside the chroot, # as against all our other access which is outside the chroot. So # we need sqlite to not open the journal. # In theory this sucks, as history could be shared. In reality # it's deep yum stuff and there should only be one yum. executeSQL(self._conn.cursor(), "PRAGMA locking_mode = EXCLUSIVE") return self._conn.cursor() def _commit(self): return self._conn.commit() def _rollback(self): return self._conn.rollback() def close(self): if self._conn is not None: self._conn.close() self._conn = None def _pkgtup2pid(self, pkgtup, checksum=None, create=True): cur = self._get_cursor() executeSQL(cur, """SELECT pkgtupid, checksum FROM pkgtups WHERE name=? AND arch=? AND epoch=? AND version=? AND release=?""", pkgtup) for sql_pkgtupid, sql_checksum in cur: if checksum is None and sql_checksum is None: return sql_pkgtupid if checksum is None: continue if sql_checksum is None: continue if checksum == sql_checksum: return sql_pkgtupid if not create: return None (n,a,e,v,r) = pkgtup (n,a,e,v,r) = (to_unicode(n),to_unicode(a), to_unicode(e),to_unicode(v),to_unicode(r)) if checksum is not None: res = executeSQL(cur, """INSERT INTO pkgtups (name, arch, epoch, version, release, checksum) VALUES (?, ?, ?, ?, ?, ?)""", (n,a,e,v,r, checksum)) else: res = executeSQL(cur, """INSERT INTO pkgtups (name, arch, epoch, version, release) VALUES (?, ?, ?, ?, ?)""", (n,a,e,v,r)) return cur.lastrowid def _apkg2pid(self, po, create=True): csum = po.returnIdSum() if csum is not None: csum = "%s:%s" % (str(csum[0]), str(csum[1])) return self._pkgtup2pid(po.pkgtup, csum, create) def _ipkg2pid(self, po, create=True): csum = None yumdb = po.yumdb_info if 'checksum_type' in yumdb and 'checksum_data' in yumdb: csum = "%s:%s" % (yumdb.checksum_type, yumdb.checksum_data) return self._pkgtup2pid(po.pkgtup, csum, create) def _hpkg2pid(self, po, create=False): return self._apkg2pid(po, create) def pkg2pid(self, po, create=True): if isinstance(po, YumInstalledPackage): return self._ipkg2pid(po, create) if isinstance(po, YumAvailablePackage): return self._apkg2pid(po, create) if isinstance(po, YumHistoryPackage): return self._hpkg2pid(po, create) return self._pkgtup2pid(po.pkgtup, None, create) @staticmethod def txmbr2state(txmbr): state = None if txmbr.output_state in (TS_INSTALL, TS_TRUEINSTALL): if txmbr.reinstall: state = 'Reinstall' elif txmbr.downgrades: state = 'Downgrade' if txmbr.output_state == TS_ERASE: if txmbr.downgraded_by: state = 'Downgraded' if state is None: state = _stcode2sttxt.get(txmbr.output_state) if state == 'Install' and txmbr.isDep: state = 'Dep-Install' return state def trans_with_pid(self, pid): cur = self._get_cursor() if cur is None: return None res = executeSQL(cur, """INSERT INTO trans_with_pkgs (tid, pkgtupid) VALUES (?, ?)""", (self._tid, pid)) return cur.lastrowid def trans_skip_pid(self, pid): cur = self._get_cursor() if cur is None or not self._update_db_file_2(): return None res = executeSQL(cur, """INSERT INTO trans_skip_pkgs (tid, pkgtupid) VALUES (?, ?)""", (self._tid, pid)) return cur.lastrowid def trans_data_pid_beg(self, pid, state): assert state is not None if not hasattr(self, '_tid') or state is None: return # Not configured to run cur = self._get_cursor() if cur is None: return # Should never happen, due to above res = executeSQL(cur, """INSERT INTO trans_data_pkgs (tid, pkgtupid, state) VALUES (?, ?, ?)""", (self._tid, pid, state)) return cur.lastrowid def trans_data_pid_end(self, pid, state): # State can be none here, Eg. TS_FAILED from rpmtrans if not hasattr(self, '_tid') or state is None: return # Not configured to run cur = self._get_cursor() if cur is None: return # Should never happen, due to above res = executeSQL(cur, """UPDATE trans_data_pkgs SET done = ? WHERE tid = ? AND pkgtupid = ? AND state = ? """, ('TRUE', self._tid, pid, state)) self._commit() def _trans_rpmdb_problem(self, problem): if not hasattr(self, '_tid'): return # Not configured to run cur = self._get_cursor() if cur is None or not self._update_db_file_2(): return None # str(problem) doesn't work if problem contains unicode(), # unicode(problem) doesn't work in python 2.4.x ... *sigh*. uproblem = to_unicode(problem.__str__()) res = executeSQL(cur, """INSERT INTO trans_rpmdb_problems (tid, problem, msg) VALUES (?, ?, ?)""", (self._tid, problem.problem, uproblem)) rpid = cur.lastrowid if not rpid: return rpid pkgs = {} pkg = problem.pkg pkgs[pkg.pkgtup] = pkg if problem.problem == 'conflicts': for pkg in problem.conflicts: pkgs[pkg.pkgtup] = pkg if problem.problem == 'duplicates': pkgs[problem.duplicate.pkgtup] = problem.duplicate for pkg in pkgs.values(): pid = self.pkg2pid(pkg) if pkg.pkgtup == problem.pkg.pkgtup: main = 'TRUE' else: main = 'FALSE' res = executeSQL(cur, """INSERT INTO trans_prob_pkgs (rpid, pkgtupid, main) VALUES (?, ?, ?)""", (rpid, pid, main)) return rpid def _trans_cmdline(self, cmdline): if not hasattr(self, '_tid'): return # Not configured to run cur = self._get_cursor() if cur is None or not self._update_db_file_2(): return None res = executeSQL(cur, """INSERT INTO trans_cmdline (tid, cmdline) VALUES (?, ?)""", (self._tid, to_unicode(cmdline))) return cur.lastrowid def beg(self, rpmdb_version, using_pkgs, txmbrs, skip_packages=[], rpmdb_problems=[], cmdline=None): cur = self._get_cursor() if cur is None: return res = executeSQL(cur, """INSERT INTO trans_beg (timestamp, rpmdb_version, loginuid) VALUES (?, ?, ?)""", (int(time.time()), str(rpmdb_version), yum.misc.getloginuid())) self._tid = cur.lastrowid for pkg in using_pkgs: pid = self._ipkg2pid(pkg) self.trans_with_pid(pid) for txmbr in txmbrs: pid = self.pkg2pid(txmbr.po) state = self.txmbr2state(txmbr) self.trans_data_pid_beg(pid, state) for pkg in skip_packages: pid = self.pkg2pid(pkg) self.trans_skip_pid(pid) for problem in rpmdb_problems: self._trans_rpmdb_problem(problem) if cmdline: self._trans_cmdline(cmdline) self._commit() def _log_errors(self, errors): cur = self._get_cursor() if cur is None: return for error in errors: error = to_unicode(error) executeSQL(cur, """INSERT INTO trans_error (tid, msg) VALUES (?, ?)""", (self._tid, error)) self._commit() def log_scriptlet_output(self, data, msg): """ Note that data can be either a real pkg. ... or not. """ if msg is None or not hasattr(self, '_tid'): return # Not configured to run cur = self._get_cursor() if cur is None: return # Should never happen, due to above for error in msg.splitlines(): error = to_unicode(error) executeSQL(cur, """INSERT INTO trans_script_stdout (tid, line) VALUES (?, ?)""", (self._tid, error)) self._commit() def _load_errors(self, tid): cur = self._get_cursor() executeSQL(cur, """SELECT msg FROM trans_error WHERE tid = ? ORDER BY mid ASC""", (tid,)) ret = [] for row in cur: ret.append(row[0]) return ret def _load_output(self, tid): cur = self._get_cursor() executeSQL(cur, """SELECT line FROM trans_script_stdout WHERE tid = ? ORDER BY lid ASC""", (tid,)) ret = [] for row in cur: ret.append(row[0]) return ret def end(self, rpmdb_version, return_code, errors=None): assert return_code or not errors if not hasattr(self, '_tid'): return # Failed at beg() time cur = self._get_cursor() if cur is None: return # Should never happen, due to above res = executeSQL(cur, """INSERT INTO trans_end (tid, timestamp, rpmdb_version, return_code) VALUES (?, ?, ?, ?)""", (self._tid,int(time.time()), str(rpmdb_version), return_code)) self._commit() if not return_code: # Simple hack, if the transaction finished. Note that this # catches the erase cases (as we still don't get pkgtups for them), # Eg. Updated elements. executeSQL(cur, """UPDATE trans_data_pkgs SET done = ? WHERE tid = ?""", ('TRUE', self._tid,)) self._commit() if errors is not None: self._log_errors(errors) del self._tid def write_addon_data(self, dataname, data): """append data to an arbitrary-named file in the history addon_path/transaction id location, returns True if write succeeded, False if not""" if not hasattr(self, '_tid'): # maybe we should raise an exception or a warning here? return False if not dataname: return False if not data: return False # make sure the tid dir exists tid_dir = self.conf.addon_path + '/' + str(self._tid) if self.conf.writable and not os.path.exists(tid_dir): try: os.makedirs(tid_dir, mode=0700) except (IOError, OSError), e: # emit a warning/raise an exception? return False # cleanup dataname safename = dataname.replace('/', '_') data_fn = tid_dir + '/' + safename try: # open file in append fo = open(data_fn, 'w+') # write data fo.write(to_utf8(data)) # flush data fo.flush() fo.close() except (IOError, OSError), e: return False # return return True def return_addon_data(self, tid, item=None): hist_and_tid = self.conf.addon_path + '/' + str(tid) + '/' addon_info = glob.glob(hist_and_tid + '*') addon_names = [ i.replace(hist_and_tid, '') for i in addon_info ] if not item: return addon_names if item not in addon_names: # XXX history needs SOME kind of exception, or warning, I think? return None fo = open(hist_and_tid + item, 'r') data = fo.read() fo.close() return data def _old_with_pkgs(self, tid): cur = self._get_cursor() executeSQL(cur, """SELECT name, arch, epoch, version, release, checksum FROM trans_with_pkgs JOIN pkgtups USING(pkgtupid) WHERE tid = ? ORDER BY name ASC, epoch ASC""", (tid,)) ret = [] for row in cur: obj = YumHistoryPackage(row[0],row[1],row[2],row[3],row[4], row[5], history=self) ret.append(obj) return ret def _old_data_pkgs(self, tid): cur = self._get_cursor() executeSQL(cur, """SELECT name, arch, epoch, version, release, checksum, done, state FROM trans_data_pkgs JOIN pkgtups USING(pkgtupid) WHERE tid = ? ORDER BY name ASC, epoch ASC, state DESC""", (tid,)) ret = [] for row in cur: obj = YumHistoryPackageState(row[0],row[1],row[2],row[3],row[4], row[7], row[5], history=self) obj.done = row[6] == 'TRUE' obj.state_installed = None if _sttxt2stcode[obj.state] in TS_INSTALL_STATES: obj.state_installed = True if _sttxt2stcode[obj.state] in TS_REMOVE_STATES: obj.state_installed = False ret.append(obj) return ret def _old_skip_pkgs(self, tid): cur = self._get_cursor() if cur is None or not self._update_db_file_2(): return [] executeSQL(cur, """SELECT name, arch, epoch, version, release, checksum FROM trans_skip_pkgs JOIN pkgtups USING(pkgtupid) WHERE tid = ? ORDER BY name ASC, epoch ASC""", (tid,)) ret = [] for row in cur: obj = YumHistoryPackage(row[0],row[1],row[2],row[3],row[4], row[5], history=self) ret.append(obj) return ret def _old_prob_pkgs(self, rpid): cur = self._get_cursor() if cur is None or not self._update_db_file_2(): return [] executeSQL(cur, """SELECT name, arch, epoch, version, release, checksum, main FROM trans_prob_pkgs JOIN pkgtups USING(pkgtupid) WHERE rpid = ? ORDER BY name ASC, epoch ASC""", (rpid,)) ret = [] for row in cur: obj = YumHistoryPackage(row[0],row[1],row[2],row[3],row[4], row[5], history=self) obj.main = row[6] == 'TRUE' ret.append(obj) return ret def _old_problems(self, tid): cur = self._get_cursor() if cur is None or not self._update_db_file_2(): return [] executeSQL(cur, """SELECT rpid, problem, msg FROM trans_rpmdb_problems WHERE tid = ? ORDER BY problem ASC, rpid ASC""", (tid,)) ret = [] for row in cur: obj = YumHistoryRpmdbProblem(self, row[0], row[1], row[2]) ret.append(obj) return ret def _old_cmdline(self, tid): cur = self._get_cursor() if cur is None or not self._update_db_file_2(): return None executeSQL(cur, """SELECT cmdline FROM trans_cmdline WHERE tid = ?""", (tid,)) ret = [] for row in cur: return row[0] return None def old(self, tids=[], limit=None, complete_transactions_only=False): """ Return a list of the last transactions, note that this includes partial transactions (ones without an end transaction). """ cur = self._get_cursor() if cur is None: return [] sql = """SELECT tid, trans_beg.timestamp AS beg_ts, trans_beg.rpmdb_version AS beg_rv, trans_end.timestamp AS end_ts, trans_end.rpmdb_version AS end_rv, loginuid, return_code FROM trans_beg JOIN trans_end USING(tid)""" # NOTE: sqlite doesn't do OUTER JOINs ... *sigh*. So we have to do it # ourself. if not complete_transactions_only: sql = """SELECT tid, trans_beg.timestamp AS beg_ts, trans_beg.rpmdb_version AS beg_rv, NULL, NULL, loginuid, NULL FROM trans_beg""" params = None if tids and len(tids) <= yum.constants.PATTERNS_INDEXED_MAX: params = tids = list(set(tids)) sql += " WHERE tid IN (%s)" % ", ".join(['?'] * len(tids)) # This relies on the fact that the PRIMARY KEY in sqlite will always # increase with each transaction. In theory we can use: # ORDER BY beg_ts DESC ... except sometimes people do installs with a # system clock that is very broken, and using that screws them forever. sql += " ORDER BY tid DESC" if limit is not None: sql += " LIMIT " + str(limit) executeSQL(cur, sql, params) ret = [] tid2obj = {} for row in cur: if tids and len(tids) > yum.constants.PATTERNS_INDEXED_MAX: if row[0] not in tids: continue obj = YumHistoryTransaction(self, row) tid2obj[row[0]] = obj ret.append(obj) sql = """SELECT tid, trans_end.timestamp AS end_ts, trans_end.rpmdb_version AS end_rv, return_code FROM trans_end""" params = tid2obj.keys() if len(params) > yum.constants.PATTERNS_INDEXED_MAX: executeSQL(cur, sql) else: sql += " WHERE tid IN (%s)" % ", ".join(['?'] * len(params)) executeSQL(cur, sql, params) for row in cur: if row[0] not in tid2obj: continue tid2obj[row[0]].end_timestamp = row[1] tid2obj[row[0]].end_rpmdbversion = row[2] tid2obj[row[0]].return_code = row[3] # Go through backwards, and see if the rpmdb versions match las = None for obj in reversed(ret): cur_rv = obj.beg_rpmdbversion las_rv = None if las is not None: las_rv = las.end_rpmdbversion if las_rv is None or cur_rv is None or (las.tid + 1) != obj.tid: pass elif las_rv != cur_rv: obj.altered_lt_rpmdb = True las.altered_gt_rpmdb = True else: obj.altered_lt_rpmdb = False las.altered_gt_rpmdb = False las = obj return ret def last(self, complete_transactions_only=True): """ This is the last full transaction. So any incomplete transactions do not count, by default. """ ret = self.old([], 1, complete_transactions_only) if not ret: return None assert len(ret) == 1 return ret[0] def _load_anydb_key(self, pkg, db, attr): cur = self._get_cursor() if cur is None or not self._update_db_file_3(): return None pid = self.pkg2pid(pkg, create=False) if pid is None: return None sql = """SELECT %(db)sdb_val FROM pkg_%(db)sdb WHERE pkgtupid=? and %(db)sdb_key=? """ % {'db' : db} executeSQL(cur, sql, (pid, attr)) for row in cur: return row[0] return None def _load_rpmdb_key(self, pkg, attr): return self._load_anydb_key(pkg, "rpm", attr) def _load_yumdb_key(self, pkg, attr): return self._load_anydb_key(pkg, "yum", attr) def _save_anydb_key(self, pkg, db, attr, val): cur = self._get_cursor() if cur is None or not self._update_db_file_3(): return None pid = self.pkg2pid(pkg, create=False) if pid is None: return None sql = """INSERT INTO pkg_%(db)sdb (pkgtupid, %(db)sdb_key, %(db)sdb_val) VALUES (?, ?, ?)""" % {'db' : db} executeSQL(cur, sql, (pid, attr, to_unicode(val))) return cur.lastrowid def _save_rpmdb_key(self, pkg, attr, val): return self._save_anydb_key(pkg, "rpm", attr, val) def _save_yumdb_key(self, pkg, attr, val): return self._save_anydb_key(pkg, "yum", attr, val) def _save_rpmdb(self, ipkg): """ Save all the data for rpmdb for this installed pkg, assumes there is no data currently. """ for attr in YumHistoryPackage._valid_rpmdb_keys: val = getattr(ipkg, attr, None) if val is None: continue if not self._save_anydb_key(ipkg, "rpm", attr, val): return False return True def _save_yumdb(self, ipkg): """ Save all the data for yumdb for this installed pkg, assumes there is no data currently. """ for attr in _YumHistPackageYumDB._valid_yumdb_keys: val = ipkg.yumdb_info.get(attr) if val is None: continue if not self._save_anydb_key(ipkg, "yum", attr, val): return False return True def _wipe_anydb(self, pkg, db): """ Delete all the data for rpmdb/yumdb for this installed pkg. """ cur = self._get_cursor() if cur is None or not self._update_db_file_3(): return False pid = self.pkg2pid(pkg, create=False) if pid is None: return False sql = """DELETE FROM pkg_%(db)sdb WHERE pkgtupid=?""" % {'db' : db} executeSQL(cur, sql, (pid,)) return True def sync_alldb(self, ipkg): """ Sync. all the data for rpmdb/yumdb for this installed pkg. """ if not self._wipe_anydb(ipkg, "rpm"): return False if not (self._wipe_anydb(ipkg, "yum") and self._save_rpmdb(ipkg) and self._save_yumdb(ipkg)): self._rollback() return False self._commit() return True def _pkg_stats(self): """ Some stats about packages in the DB. """ ret = {'nevrac' : 0, 'nevra' : 0, 'nevr' : 0, 'na' : 0, 'rpmdb' : 0, 'yumdb' : 0, } cur = self._get_cursor() if cur is None or not self._update_db_file_3(): return False data = (('nevrac', "COUNT(*)", "pkgtups"), ('na', "COUNT(DISTINCT(name || arch))", "pkgtups"), ('nevra',"COUNT(DISTINCT(name||version||epoch||release||arch))", "pkgtups"), ('nevr', "COUNT(DISTINCT(name||version||epoch||release))", "pkgtups"), ('rpmdb', "COUNT(DISTINCT(pkgtupid))", "pkg_rpmdb"), ('yumdb', "COUNT(DISTINCT(pkgtupid))", "pkg_yumdb")) for key, bsql, esql in data: executeSQL(cur, "SELECT %s FROM %s" % (bsql, esql)) for row in cur: ret[key] = row[0] return ret def _yieldSQLDataList(self, patterns, fields, ignore_case): """Yields all the package data for the given params. """ cur = self._get_cursor() qsql = _FULL_PARSE_QUERY_BEG pat_sqls = [] pat_data = [] for (pattern, rest) in patterns: for field in fields: if ignore_case: pat_sqls.append("%s LIKE ?%s" % (field, rest)) else: pat_sqls.append("%s %s ?" % (field, rest)) pat_data.append(pattern) assert pat_sqls qsql += " OR ".join(pat_sqls) executeSQL(cur, qsql, pat_data) for x in cur: yield x def search(self, patterns, ignore_case=True): """ Search for history transactions which contain specified packages al. la. "yum list". Returns transaction ids. """ # Search packages ... kind of sucks that it's search not list, pkglist? cur = self._get_cursor() if cur is None: return set() # This is kind of a hack, we can't do 'y[u]m' in SQL. In real yum # we manually load everything and then do it inside yum (which is slow # and a lot of code, but nobody uses it anyway and we already had the # code). Here we don't have the code though, and still nobody will use # it. So we cheat: # 1. Convert 'y[u]m' into 'y?m' ... it returns more answers than it # should, but the correct answers are there. # 2. Convert 'y[m' info 'y!m' ... neither will match anything, so w/e. patterns = [re.sub('\[[^]]+\]', '?', x).replace('[', '!') for x in patterns] data = _setupHistorySearchSQL(patterns, ignore_case) (need_full, npatterns, fields, names) = data ret = [] pkgtupids = set() if npatterns: for row in self._yieldSQLDataList(npatterns, fields, ignore_case): pkgtupids.add(row[0]) else: # Too many patterns, *sigh* pat_max = PATTERNS_MAX if not need_full: pat_max = PATTERNS_INDEXED_MAX for npatterns in yum.misc.seq_max_split(patterns, pat_max): data = _setupHistorySearchSQL(npatterns, ignore_case) (need_full, nps, fields, names) = data assert nps for row in self._yieldSQLDataList(nps, fields, ignore_case): pkgtupids.add(row[0]) sql = """SELECT tid FROM trans_data_pkgs WHERE pkgtupid IN """ sql += "(%s)" % ",".join(['?'] * len(pkgtupids)) params = list(pkgtupids) tids = set() if len(params) > yum.constants.PATTERNS_INDEXED_MAX: executeSQL(cur, """SELECT tid,pkgtupid FROM trans_data_pkgs""") for row in cur: if row[1] in params: tids.add(row[0]) return tids if not params: return tids executeSQL(cur, sql, params) for row in cur: tids.add(row[0]) return tids _update_ops_3 = ['''\ \ CREATE TABLE pkg_rpmdb ( pkgtupid INTEGER NOT NULL REFERENCES pkgtups, rpmdb_key TEXT NOT NULL, rpmdb_val TEXT NOT NULL); ''', '''\ CREATE INDEX i_pkgkey_rpmdb ON pkg_rpmdb (pkgtupid, rpmdb_key); ''', '''\ CREATE TABLE pkg_yumdb ( pkgtupid INTEGER NOT NULL REFERENCES pkgtups, yumdb_key TEXT NOT NULL, yumdb_val TEXT NOT NULL); ''', '''\ CREATE INDEX i_pkgkey_yumdb ON pkg_yumdb (pkgtupid, yumdb_key); '''] # pylint: disable-msg=E0203 def _update_db_file_3(self): """ Update to version 3 of history, rpmdb/yumdb data. """ if not self._update_db_file_2(): return False if hasattr(self, '_cached_updated_3'): return self._cached_updated_3 cur = self._get_cursor() if cur is None: return False executeSQL(cur, "PRAGMA table_info(pkg_yumdb)") # If we get anything, we're fine. There might be a better way of # saying "anything" but this works. for ob in cur: break else: for op in self._update_ops_3: cur.execute(op) self._commit() self._cached_updated_3 = True return True _update_ops_2 = ['''\ \ CREATE TABLE trans_skip_pkgs ( tid INTEGER NOT NULL REFERENCES trans_beg, pkgtupid INTEGER NOT NULL REFERENCES pkgtups); ''', '''\ \ CREATE TABLE trans_cmdline ( tid INTEGER NOT NULL REFERENCES trans_beg, cmdline TEXT NOT NULL); ''', '''\ \ CREATE TABLE trans_rpmdb_problems ( rpid INTEGER PRIMARY KEY, tid INTEGER NOT NULL REFERENCES trans_beg, problem TEXT NOT NULL, msg TEXT NOT NULL); ''', '''\ \ CREATE TABLE trans_prob_pkgs ( rpid INTEGER NOT NULL REFERENCES trans_rpmdb_problems, pkgtupid INTEGER NOT NULL REFERENCES pkgtups, main BOOL NOT NULL DEFAULT FALSE); ''', '''\ \ CREATE VIEW vtrans_data_pkgs AS SELECT tid,name,epoch,version,release,arch,pkgtupid, state,done, name || '-' || epoch || ':' || version || '-' || release || '.' || arch AS nevra FROM trans_data_pkgs JOIN pkgtups USING(pkgtupid) ORDER BY name; ''', '''\ \ CREATE VIEW vtrans_with_pkgs AS SELECT tid,name,epoch,version,release,arch,pkgtupid, name || '-' || epoch || ':' || version || '-' || release || '.' || arch AS nevra FROM trans_with_pkgs JOIN pkgtups USING(pkgtupid) ORDER BY name; ''', '''\ \ CREATE VIEW vtrans_skip_pkgs AS SELECT tid,name,epoch,version,release,arch,pkgtupid, name || '-' || epoch || ':' || version || '-' || release || '.' || arch AS nevra FROM trans_skip_pkgs JOIN pkgtups USING(pkgtupid) ORDER BY name; ''', # NOTE: Old versions of sqlite don't like the normal way to do the next # view. So we do it with the select. It's for debugging only, so # no big deal. '''\ \ CREATE VIEW vtrans_prob_pkgs2 AS SELECT tid,rpid,name,epoch,version,release,arch,pkgtups.pkgtupid, main,problem,msg, name || '-' || epoch || ':' || version || '-' || release || '.' || arch AS nevra FROM (SELECT * FROM trans_prob_pkgs,trans_rpmdb_problems WHERE trans_prob_pkgs.rpid=trans_rpmdb_problems.rpid) JOIN pkgtups USING(pkgtupid) ORDER BY name; '''] def _update_db_file_2(self): """ Update to version 2 of history, includes trans_skip_pkgs. """ if not self.conf.writable: return False if hasattr(self, '_cached_updated_2'): return self._cached_updated_2 cur = self._get_cursor() if cur is None: return False executeSQL(cur, "PRAGMA table_info(trans_skip_pkgs)") # If we get anything, we're fine. There might be a better way of # saying "anything" but this works. for ob in cur: break else: for op in self._update_ops_2: cur.execute(op) self._commit() self._cached_updated_2 = True return True # pylint: enable-msg=E0203 def _create_db_file(self): """ Create a new history DB file, populating tables etc. """ self._db_date = time.strftime('%Y-%m-%d') _db_file = '%s/%s-%s.%s' % (self.conf.db_path, 'history', self._db_date, 'sqlite') if self._db_file == _db_file: os.rename(_db_file, _db_file + '.old') # Just in case ... move the journal file too. if os.path.exists(_db_file + '-journal'): os.rename(_db_file + '-journal', _db_file + '-journal.old') self._db_file = _db_file if not self.conf.writable: return False if not os.path.exists(self._db_file): # make them default to 0600 - sysadmin can change it later # if they want fo = os.open(self._db_file, os.O_CREAT, 0600) os.close(fo) cur = self._get_cursor() ops = ['''\ CREATE TABLE trans_beg ( tid INTEGER PRIMARY KEY, timestamp INTEGER NOT NULL, rpmdb_version TEXT NOT NULL, loginuid INTEGER); ''', '''\ CREATE TABLE trans_end ( tid INTEGER PRIMARY KEY REFERENCES trans_beg, timestamp INTEGER NOT NULL, rpmdb_version TEXT NOT NULL, return_code INTEGER NOT NULL); ''', '''\ \ CREATE TABLE trans_with_pkgs ( tid INTEGER NOT NULL REFERENCES trans_beg, pkgtupid INTEGER NOT NULL REFERENCES pkgtups); ''', '''\ \ CREATE TABLE trans_error ( mid INTEGER PRIMARY KEY, tid INTEGER NOT NULL REFERENCES trans_beg, msg TEXT NOT NULL); ''', '''\ CREATE TABLE trans_script_stdout ( lid INTEGER PRIMARY KEY, tid INTEGER NOT NULL REFERENCES trans_beg, line TEXT NOT NULL); ''', '''\ \ CREATE TABLE trans_data_pkgs ( tid INTEGER NOT NULL REFERENCES trans_beg, pkgtupid INTEGER NOT NULL REFERENCES pkgtups, done BOOL NOT NULL DEFAULT FALSE, state TEXT NOT NULL); ''', '''\ \ CREATE TABLE pkgtups ( pkgtupid INTEGER PRIMARY KEY, name TEXT NOT NULL, arch TEXT NOT NULL, epoch TEXT NOT NULL, version TEXT NOT NULL, release TEXT NOT NULL, checksum TEXT); ''', '''\ CREATE INDEX i_pkgtup_naevr ON pkgtups (name, arch, epoch, version, release); '''] for op in ops: cur.execute(op) for op in self._update_ops_2: cur.execute(op) for op in self._update_ops_3: cur.execute(op) self._commit() return True # Pasted from sqlitesack _FULL_PARSE_QUERY_BEG = """ SELECT pkgtupid,name,epoch,version,release,arch, name || "." || arch AS sql_nameArch, name || "-" || version || "-" || release || "." || arch AS sql_nameVerRelArch, name || "-" || version AS sql_nameVer, name || "-" || version || "-" || release AS sql_nameVerRel, epoch || ":" || name || "-" || version || "-" || release || "." || arch AS sql_envra, name || "-" || epoch || ":" || version || "-" || release || "." || arch AS sql_nevra FROM pkgtups WHERE """