[ SEA-GHOST MINI SHELL]
#!/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
"""
SEA-GHOST - SHELL CODING BY SEA-GHOST