ok
Direktori : /proc/self/root/proc/self/root/lib/python2.7/site-packages/yum/ |
Current File : //proc/self/root/proc/self/root/lib/python2.7/site-packages/yum/updateinfo.py |
import os.path import re from yum.i18n import _, P_ from yum.constants import * from yum.logginglevels import INFO_1 import rpmUtils.miscutils import misc import fnmatch # newpackages is weird, in that we'll never display that because we filter to # things relevant to installed pkgs... _update_info_types_ = ("security", "bugfix", "enhancement", "recommended", "newpackage") def _rpm_tup_vercmp(tup1, tup2): """ Compare two "std." tuples, (n, a, e, v, r). """ return rpmUtils.miscutils.compareEVR((tup1[2], tup1[3], tup1[4]), (tup2[2], tup2[3], tup2[4])) def _ysp_safe_refs(refs): """ Sometimes refs == None, if so return the empty list here. So we don't have to check everywhere. """ if not refs: return [] return refs def _match_sec_cmd(sec_cmds, pkgname, notice): for i in sec_cmds: if fnmatch.fnmatch(pkgname, i): return i if fnmatch.fnmatch(notice['update_id'], i): return i cvei = i if not (i.startswith("CVE-") or i.startswith("*")): cvei = 'CVE-' + i for ref in _ysp_safe_refs(notice['references']): if ref['id'] is None: continue if fnmatch.fnmatch(ref['id'], i): return i if fnmatch.fnmatch(ref['id'], cvei): return i return None def _has_id(used_map, refs, ref_type, ref_ids): ''' Check if the given ID is a match. ''' for ref in _ysp_safe_refs(refs): if ref['type'] != ref_type: continue if ref['id'] not in ref_ids: continue used_map[ref_type][ref['id']] = True return ref return None def _ysp_should_filter_pkg(opts, pkgname, notice, used_map): """ Do the package filtering for should_show and should_keep. """ rcmd = _match_sec_cmd(opts.sec_cmds, pkgname, notice) if rcmd: used_map['cmd'][rcmd] = True return True elif opts.advisory and notice['update_id'] in opts.advisory: used_map['id'][notice['update_id']] = True return True elif (opts.severity and notice['type'] == 'security' and notice['severity'] in opts.severity): used_map['sev'][notice['severity']] = True return True elif opts.cve and _has_id(used_map, notice['references'], "cve", opts.cve): return True elif opts.bz and _has_id(used_map, notice['references'],"bugzilla",opts.bz): return True # FIXME: Add opts for enhancement/etc.? -- __update_info_types__ elif (opts.security and notice['type'] == 'security' and (not opts.severity or 'severity' not in notice or not notice['severity'])): return True elif opts.bugfixes and notice['type'] == 'bugfix': return True elif not (opts.advisory or opts.cve or opts.bz or opts.security or opts.bugfixes or opts.sec_cmds or opts.severity): return True # This is only possible from should_show_pkg return False def _ysp_has_info_md(rname, md): if rname in _update_info_types_: if md['type'] == rname: return md for ref in _ysp_safe_refs(md['references']): if ref['type'] != rname: continue return md def _no_options(opts): return not (opts.security or opts.bugfixes or opts.advisory or opts.bz or opts.cve or opts.severity) def _updateinfofilter2opts(updateinfo_filters): opts = misc.GenericHolder() opts.sec_cmds = [] opts.advisory = updateinfo_filters.get('advs', []) opts.bz = updateinfo_filters.get('bzs', []) opts.cve = updateinfo_filters.get('cves', []) opts.severity = updateinfo_filters.get('sevs', []) opts.bugfixes = updateinfo_filters.get('bugfix', False) opts.security = updateinfo_filters.get('security', False) return opts def _args2filters(args): # Basically allow args to turn into security filters, for shell command etc. T_map = {'advs' : 'advs', 'advisory' : 'advs', 'advisories' : 'advs', 'bzs' : 'bzs', 'bz' : 'bzs', 'cves' : 'cves', 'cve' : 'cves', 'security-severity' : 'sevs', 'security-severities' : 'sevs', 'severity' : 'sevs', 'severities' : 'sevs', 'sevs' : 'sevs', 'sev' : 'sevs', 'security' : 'security', 'sec' : 'security', 'bugfix' : 'bugfix', 'bugfixes' : 'bugfix', 'bugs' : 'bugfix', } filters = {'security' : False, 'bugfix' : False} for arg0 in args: arg0 = arg0.replace(" ", ',') T = 'advs' if '=' in arg0: T, arg1 = arg0.split('=', 1) elif arg0 not in T_map: arg1 = arg0 else: T = arg0 arg1 = 'true' if T not in T_map: continue # Error message? T = T_map[T] if T in ('security', 'bugfix'): filters[T] = not filters[T] else: filters[T] = filters.get(T, []) + arg1.split(',') return filters def _ysp_gen_opts(filters, sec_cmds=None): def strip_respin(id_): # Example: RHSA-2016:1234-2 -> RHSA-2016:1234 pattern = r'^(RH[BES]A\-\d+\:\d+)(\-\d+)?$' match = re.match(pattern, id_) if match: return match.group(1) return id_ opts = _updateinfofilter2opts(filters) if sec_cmds is not None: opts.sec_cmds = sec_cmds # If a RH advisory was specified with a respin suffix, strip it out, as we # don't include these suffixes in the notice update_id attribute either (we # use the version attribute for that). Note that there's no ambiguity in # which notice version we should match then, as updateinfo.xml should only # contain one per advisory ID (we give a warning when duplicate IDs are # detected in it). The reason we are handling this is that we sometimes # refer to advisories in this form (e.g. on rhn.redhat.com/errata/...) and # the user may then use it with yum too, in which case we would yield no # matches. # # However, we used to put these suffixes in update_id in the past, so let's # also keep the original (unstripped) form around in opts, just in case we # are dealing with such an old updateinfo.xml. for attr in ['sec_cmds', 'advisory']: oldlist = getattr(opts, attr) stripped = map(strip_respin, oldlist) newlist = list(set(oldlist) | set(stripped)) setattr(opts, attr, newlist) return opts def _ysp_gen_used_map(opts): used_map = {'bugzilla' : {}, 'cve' : {}, 'id' : {}, 'cmd' : {}, 'sev' : {}} if True: return used_map for i in opts.sec_cmds: used_map['cmd'][i] = False for i in opts.advisory: used_map['id'][i] = False for i in opts.bz: used_map['bugzilla'][i] = False for i in opts.cve: used_map['cve'][i] = False for i in opts.severity: used_map['sev'][i] = False return used_map def _ysp_chk_used_map(used_map, msg): for i in used_map['cmd']: if not used_map['cmd'][i]: msg('No update information found for \"%s\"' % i) for i in used_map['id']: if not used_map['id'][i]: msg('Advisory \"%s\" not found applicable for this system' % i) for i in used_map['bugzilla']: if not used_map['bugzilla'][i]: msg('BZ \"%s\" not found applicable for this system' % i) for i in used_map['cve']: if not used_map['cve'][i]: msg('CVE \"%s\" not found applicable for this system' % i) for i in used_map['sev']: if not used_map['sev'][i]: msg('Severity \"%s\" not found applicable for this system' % i) def _get_name2pkgtup(base, pkgtups): name2tup = {} for pkgtup in pkgtups: # Get the latest "old" pkgtups if (pkgtup[0] in name2tup and _rpm_tup_vercmp(name2tup[pkgtup[0]], pkgtup) > 0): continue name2tup[pkgtup[0]] = pkgtup return name2tup def _get_name2oldpkgtup(base): """ Get the pkgtups for all installed pkgs. which have an update. """ oupdates = map(lambda x: x[1], base.up.getUpdatesTuples()) return _get_name2pkgtup(base, oupdates) def _get_name2instpkgtup(base): """ Get the pkgtups for all installed pkgs. """ return _get_name2pkgtup(base, base.rpmdb.simplePkgList()) def _get_name2allpkgtup(base): """ Get the pkgtups for all installed pkgs. and munge that to be the first possible pkgtup. """ ofirst = [(pt[0], pt[1], '0','0','0') for pt in base.rpmdb.simplePkgList()] return _get_name2pkgtup(base, ofirst) def _get_name2aallpkgtup(base): """ Get the pkgtups for all available pkgs. and munge that to be the first possible pkgtup. """ ofirst = [(pt[0], pt[1],'0','0','0') for pt in base.pkgSack.simplePkgList()] return _get_name2pkgtup(base, ofirst) # You might think we'd just call delPackage # and indeed that works for list updates etc. # # __but__ that doesn't work for dependancies on real updates # # So to fix deps. we need to do it at the preresolve stage and take the # "transaction package list" and then remove packages from that. # # __but__ that doesn't work for lists ... so we do it two ways # def _ysp_should_keep_pkg(opts, pkgtup, md_info, used_map): """ Do we want to keep this package to satisfy the security limits. """ name = pkgtup[0] for (pkgtup, notice) in md_info.get_applicable_notices(pkgtup): if _ysp_should_filter_pkg(opts, name, notice, used_map): return True return False def _repos_downloaded(repos): dled = True for repo in repos: try: data = repo.repoXML.getData('updateinfo'); except: continue # No data is fine... # Note that this doesn't check that it's decompressed... path = repo.cachedir +'/'+ os.path.basename(data.location[1]) if not os.path.exists(path): dled = False break return dled def _check_running_kernel(yb, md_info, msg): kern_pkgtup = misc.get_running_kernel_pkgtup(yb.ts) if kern_pkgtup[0] is None: return found_sec = False for (pkgtup, notice) in md_info.get_applicable_notices(kern_pkgtup): if found_sec or notice['type'] != 'security': continue found_sec = True ipkg = yb.rpmdb.searchPkgTuple(pkgtup) if not ipkg: continue # Not installed ipkg = ipkg[0] e = '' if kern_pkgtup[2] != '0': e = '%s:' % kern_pkgtup[2] rpkg = '%s-%s%s-%s.%s' % (kern_pkgtup[0], e, kern_pkgtup[3], kern_pkgtup[4], kern_pkgtup[1]) msg(_('Security: %s is an installed security update') % ipkg) msg(_('Security: %s is the currently running version') % rpkg) break def remove_txmbrs(base, filters=None): ''' Remove packages from the transaction, using the updateinfo data. ''' def ysp_del_pkg(tspkg): """ Deletes a package within a transaction. """ base.verbose_logger.log(INFO_1, _(" --> %s from %s removed (updateinfo)") % (tspkg.po, tspkg.po.ui_from_repo)) tsinfo.remove(tspkg.pkgtup) if filters is None: filters = base.updateinfo_filters opts = _ysp_gen_opts(filters) if _no_options(opts): return 0, 0, 0 md_info = base.upinfo tot = 0 cnt = 0 used_map = _ysp_gen_used_map(opts) tsinfo = base.tsInfo tspkgs = tsinfo.getMembers() # Ok, here we keep any pkgs that pass "ysp" tests, then we keep all # related pkgs ... Ie. "installed" version marked for removal. keep_pkgs = set() count_states = set(TS_INSTALL_STATES + [TS_ERASE]) count_pkgs = set() for tspkg in tspkgs: if tspkg.output_state in count_states: count_pkgs.add(tspkg.po) name2tup = _get_name2oldpkgtup(base) for tspkg in tspkgs: if tspkg.output_state in count_states: tot += 1 name = tspkg.po.name if (name not in name2tup or not _ysp_should_keep_pkg(opts, name2tup[name], md_info, used_map)): continue if tspkg.output_state in count_states: cnt += 1 keep_pkgs.add(tspkg.po) scnt = cnt mini_depsolve_again = True while mini_depsolve_again: mini_depsolve_again = False for tspkg in tspkgs: if tspkg.po in keep_pkgs: # Find any related pkgs, and add them: for (rpkg, reason) in tspkg.relatedto: if rpkg not in keep_pkgs: if rpkg in count_pkgs: cnt += 1 keep_pkgs.add(rpkg) mini_depsolve_again = True else: # If related to any keep pkgs, add us for (rpkg, reason) in tspkg.relatedto: if rpkg in keep_pkgs: if rpkg in count_pkgs: cnt += 1 keep_pkgs.add(tspkg.po) mini_depsolve_again = True break for tspkg in tspkgs: if tspkg.po not in keep_pkgs: ysp_del_pkg(tspkg) _ysp_chk_used_map(used_map, lambda x: base.verbose_logger.warn("%s", x)) if cnt: base.verbose_logger.log(INFO_1, _('%d package(s) needed (+%d related) for security, out of %d available') % (scnt, cnt - scnt, tot)) else: base.verbose_logger.log(INFO_1, _('No packages needed for security; %d packages available') % tot) return cnt, scnt, tot def exclude_updates(base, filters=None): ''' Exclude all packages to do with updates, using the updateinfo data. ''' def ysp_del_pkg(pkg, reason="updateinfo"): """ Deletes a package from all trees that yum knows about """ base.verbose_logger.log(INFO_1, _(" --> %s from %s excluded (%s)") % (pkg,pkg.repoid, reason)) pkg.repo.sack.delPackage(pkg) if filters is None: filters = base.updateinfo_filters opts = _ysp_gen_opts(filters) if _no_options(opts): return 0, 0 md_info = base.upinfo used_map = _ysp_gen_used_map(opts) tot = len(set(base.doPackageLists(pkgnarrow='updates').updates + \ base.doPackageLists(pkgnarrow='obsoletes').obsoletes)) pkgs = base.pkgSack.returnPackages() name2tup = _get_name2oldpkgtup(base) pkgs_to_del = [] for pkg in pkgs: name = pkg.name if (name not in name2tup or not _ysp_should_keep_pkg(opts, name2tup[name], md_info, used_map)): pkgs_to_del.append(pkg.name) continue if pkgs_to_del: for p in base.doPackageLists(pkgnarrow='available', patterns=pkgs_to_del, showdups=True).available: ysp_del_pkg(p) cnt = len(set(base.doPackageLists(pkgnarrow='updates').updates + \ base.doPackageLists(pkgnarrow='obsoletes').obsoletes)) _ysp_chk_used_map(used_map, lambda x: base.verbose_logger.warn("%s", x)) if cnt: base.verbose_logger.log(INFO_1, _('%d package(s) needed for security, out of %d available') % (cnt, tot)) else: base.verbose_logger.log(INFO_1, _('No packages needed for security; %d packages available' % tot)) return cnt, tot def exclude_all(base, filters=None): ''' Exclude all packages, using the updateinfo data. ''' def ysp_del_pkg(pkg, reason="updateinfo"): """ Deletes a package from all trees that yum knows about """ base.verbose_logger.log(INFO_1, _(" --> %s from %s excluded (%s)") % (pkg,pkg.repoid, reason)) pkg.repo.sack.delPackage(pkg) if filters is None: filters = base.updateinfo_filters opts = _ysp_gen_opts(filters) if _no_options(opts): return 0, 0 md_info = base.upinfo used_map = _ysp_gen_used_map(opts) pkgs = base.pkgSack.returnPackages() name2tup = _get_name2aallpkgtup(base) tot = 0 cnt = 0 for pkg in pkgs: tot += 1 name = pkg.name if (name not in name2tup or not _ysp_should_keep_pkg(opts, name2tup[name], md_info, used_map)): ysp_del_pkg(pkg) continue cnt += 1 _ysp_chk_used_map(used_map, lambda x: base.verbose_logger.warn("%s", x)) if cnt: base.verbose_logger.log(INFO_1, _('%d package(s) needed for security, out of %d available') % (cnt, tot)) else: base.verbose_logger.log(INFO_1, _('No packages needed for security; %d packages available' % tot)) return cnt, tot def update_minimal(base, extcmds=[]): """Mark the specified items to be updated, in the minimal way. :param extcmds: the user specified arguments :return: a list of transaction members added to the transaction set by this function """ txmbrs = [] used_map = _ysp_gen_used_map(base.updateinfo_filters) opts = _ysp_gen_opts(base.updateinfo_filters) ndata = _no_options(opts) # NOTE: Not doing obsoletes processing atm. ... maybe we should? -- # Also worth pointing out we don't go backwards for obsoletes in the: # update --security case etc. # obsoletes = base.up.getObsoletesTuples(newest=False) # for (obsoleting, installed) in sorted(obsoletes, key=lambda x: x[0]): # pass # Tuples == (n, a, e, v, r) oupdates = map(lambda x: x[1], base.up.getUpdatesTuples()) for oldpkgtup in sorted(oupdates): data = base.upinfo.get_applicable_notices(oldpkgtup) if ndata: # No options means pick the oldest update data.reverse() for (pkgtup, notice) in data: name = pkgtup[0] if extcmds and not _match_sec_cmd(extcmds, name, notice): continue if (not ndata and not _ysp_should_filter_pkg(opts, name, notice, used_map)): continue txmbrs.extend(base.update(name=pkgtup[0], arch=pkgtup[1], epoch=pkgtup[2], version=pkgtup[3], release=pkgtup[4])) break # _ysp_chk_used_map(used_map, msg) return txmbrs