Remove unused package sets and glsa stuff.

svn path=/main/branches/2.1.6/; revision=12076

14 files changed, 0 insertions, 1530 deletions

diff --git a/bin/glsa-check b/bin/glsa-check
deleted file mode 100644
index 8aea638a5..000000000
--- a/bin/glsa-check
+++ /dev/null
@@ -1,337 +0,0 @@
-#!/usr/bin/python
-
-# $Header: $
-# This program is licensed under the GPL, version 2
-
-import os
-import sys
-
-try:
-	import portage
-except ImportError:
-	from os import path as osp
-	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "pym"))
-	import portage
-
-from portage.output import *
-
-from getopt import getopt, GetoptError
-
-__program__ = "glsa-check"
-__author__ = "Marius Mauch <genone@gentoo.org>"
-__version__ = "1.0"
-
-optionmap = [
-["-l", "--list", "list all unapplied GLSA"],
-["-d", "--dump", "--print", "show all information about the given GLSA"],
-["-t", "--test", "test if this system is affected by the given GLSA"],
-["-p", "--pretend", "show the necessary commands to apply this GLSA"],
-["-f", "--fix", "try to auto-apply this GLSA (experimental)"],
-["-i", "--inject", "inject the given GLSA into the checkfile"],
-["-n", "--nocolor", "disable colors (option)"],
-["-e", "--emergelike", "do not use a least-change algorithm (option)"],
-["-h", "--help", "show this help message"],
-["-V", "--version", "some information about this tool"],
-["-v", "--verbose", "print more information (option)"],
-["-c", "--cve", "show CAN ids in listing mode (option)"],
-["-m", "--mail", "send a mail with the given GLSAs to the administrator"]
-]
-
-# option parsing
-args = []
-params = []
-try:
-	args, params = getopt(sys.argv[1:], "".join([o[0][1] for o in optionmap]), \
-		[x[2:] for x in reduce(lambda x,y: x+y, [z[1:-1] for z in optionmap])])
-#		["dump", "print", "list", "pretend", "fix", "inject", "help", "verbose", "version", "test", "nocolor", "cve", "mail"])
-	args = [a for a,b in args]
-	
-	for option in ["--nocolor", "-n"]:
-		if option in args:
-			nocolor()
-			args.remove(option)
-			
-	verbose = False
-	for option in ["--verbose", "-v"]:
-		if option in args:
-			verbose = True
-			args.remove(option)
-
-	list_cve = False
-	for option in ["--cve", "-c"]:
-		if option in args:
-			list_cve = True
-			args.remove(option)
-	
-	least_change = True
-	for option in ["--emergelike", "-e"]:
-		if option in args:
-			least_change = False
-			args.remove(option)
-
-	# sanity checking
-	if len(args) <= 0:
-		sys.stderr.write("no option given: what should I do ?\n")
-		mode="help"
-	elif len(args) > 1:
-		sys.stderr.write("please use only one command per call\n")
-		mode = "help"
-	else:
-		# in what mode are we ?
-		args = args[0]
-		for m in optionmap:
-			if args in [o for o in m[:-1]]:
-				mode = m[1][2:]
-
-except GetoptError, e:
-	sys.stderr.write("unknown option given: ")
-	sys.stderr.write(str(e)+"\n")
-	mode = "help"
-
-# we need a set of glsa for most operation modes
-if len(params) <= 0 and mode in ["fix", "test", "pretend", "dump", "inject", "mail"]:
-	sys.stderr.write("\nno GLSA given, so we'll do nothing for now. \n")
-	sys.stderr.write("If you want to run on all GLSA please tell me so \n")
-	sys.stderr.write("(specify \"all\" as parameter)\n\n")
-	mode = "help"
-elif len(params) <= 0 and mode == "list":
-	params.append("new")
-	
-# show help message
-if mode == "help":
-	sys.stderr.write("\nSyntax: glsa-check <option> [glsa-list]\n\n")
-	for m in optionmap:
-		sys.stderr.write(m[0] + "\t" + m[1] + "   \t: " + m[-1] + "\n")
-		for o in m[2:-1]:
-			sys.stderr.write("\t" + o + "\n")
-	sys.stderr.write("\nglsa-list can contain an arbitrary number of GLSA ids, \n")
-	sys.stderr.write("filenames containing GLSAs or the special identifiers \n")
-	sys.stderr.write("'all', 'new' and 'affected'\n")
-	sys.exit(1)
-
-# we need root priviledges for write access
-if mode in ["fix", "inject"] and os.geteuid() != 0:
-	sys.stderr.write("\nThis tool needs root access to "+mode+" this GLSA\n\n")
-	sys.exit(2)
-
-# show version and copyright information
-if mode == "version":
-	sys.stderr.write("\n"+ __program__ + ", version " + __version__ + "\n")
-	sys.stderr.write("Author: " + __author__ + "\n")
-	sys.stderr.write("This program is licensed under the GPL, version 2\n\n")
-	sys.exit(0)
-
-# delay this for speed increase
-from portage.glsa import *
-
-vardb = portage.db[portage.settings["ROOT"]]["vartree"].dbapi
-portdb = portage.db["/"]["porttree"].dbapi
-
-# build glsa lists
-completelist = get_glsa_list(portage.settings)
-
-checklist = get_applied_glsas(portage.settings)
-todolist = [e for e in completelist if e not in checklist]
-
-glsalist = []
-if "new" in params:
-	glsalist = todolist
-	params.remove("new")
-	
-if "all" in params:
-	glsalist = completelist
-	params.remove("all")
-if "affected" in params:
-	# replaced completelist with todolist on request of wschlich
-	for x in todolist:
-		try:
-			myglsa = Glsa(x, portage.settings, vardb, portdb)
-		except (GlsaTypeException, GlsaFormatException), e:
-			if verbose:
-				sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (x, e)))
-			continue
-		if myglsa.isVulnerable():
-			glsalist.append(x)
-	params.remove("affected")
-
-# remove invalid parameters
-for p in params[:]:
-	if not (p in completelist or os.path.exists(p)):
-		sys.stderr.write(("(removing %s from parameter list as it isn't a valid GLSA specification)\n" % p))
-		params.remove(p)
-
-glsalist.extend([g for g in params if g not in glsalist])
-
-def summarylist(myglsalist, fd1=sys.stdout, fd2=sys.stderr):
-	fd2.write(white("[A]")+" means this GLSA was already applied,\n")
-	fd2.write(green("[U]")+" means the system is not affected and\n")
-	fd2.write(red("[N]")+" indicates that the system might be affected.\n\n")
-
-	myglsalist.sort()
-	for myid in myglsalist:
-		try:
-			myglsa = Glsa(myid, portage.settings, vardb, portdb)
-		except (GlsaTypeException, GlsaFormatException), e:
-			if verbose:
-				fd2.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
-			continue
-		if myglsa.isApplied():
-			status = "[A]"
-			color = white
-		elif myglsa.isVulnerable():
-			status = "[N]"
-			color = red
-		else:
-			status = "[U]"
-			color = green
-
-		if verbose:
-			access = ("[%-8s] " % myglsa.access)
-		else:
-			access=""
-
-		fd1.write(color(myglsa.nr) + " " + color(status) + " " + color(access) + myglsa.title + " (")
-		if not verbose:
-			for pkg in myglsa.packages.keys()[:3]:
-				fd1.write(" " + pkg + " ")
-			if len(myglsa.packages) > 3:
-				fd1.write("... ")
-		else:
-			for pkg in myglsa.packages.keys():
-				mylist = vardb.match(portage.dep_getkey(pkg))
-				if len(mylist) > 0:
-					pkg = color(" ".join(mylist))
-				fd1.write(" " + pkg + " ")
-
-		fd1.write(")")
-		if list_cve:
-			fd1.write(" "+(",".join([r[:13] for r in myglsa.references if r[:4] in ["CAN-", "CVE-"]])))
-		fd1.write("\n")		
-	return 0
-
-if mode == "list":
-	sys.exit(summarylist(glsalist))
-
-# dump, fix, inject and fix are nearly the same code, only the glsa method call differs
-if mode in ["dump", "fix", "inject", "pretend"]:
-	for myid in glsalist:
-		try:
-			myglsa = Glsa(myid, portage.settings, vardb, portdb)
-		except (GlsaTypeException, GlsaFormatException), e:
-			if verbose:
-				sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
-			continue
-		if mode == "dump":
-			myglsa.dump()
-		elif mode == "fix":
-			sys.stdout.write("fixing "+myid+"\n")
-			mergelist = myglsa.getMergeList(least_change=least_change)
-			for pkg in mergelist:
-				sys.stdout.write(">>> merging "+pkg+"\n")
-				# using emerge for the actual merging as it contains the dependency
-				# code and we want to be consistent in behaviour. Also this functionality
-				# will be integrated in emerge later, so it shouldn't hurt much.
-				emergecmd = "emerge --oneshot " + portage.settings["EMERGE_OPTS"] + " =" + pkg
-				if verbose:
-					sys.stderr.write(emergecmd+"\n")
-				exitcode = os.system(emergecmd)
-				# system() returns the exitcode in the high byte of a 16bit integer
-				if exitcode >= 1<<8:
-					exitcode >>= 8
-				if exitcode:
-					sys.exit(exitcode)
-			myglsa.inject()
-		elif mode == "pretend":
-			sys.stdout.write("Checking GLSA "+myid+"\n")
-			mergelist = myglsa.getMergeList(least_change=least_change)
-			if mergelist:
-				sys.stdout.write("The following updates will be performed for this GLSA:\n")
-				for pkg in mergelist:
-					oldver = None
-					for x in vardb.match(portage.dep_getkey(pkg)):
-						if vardb.aux_get(x, ["SLOT"]) == portdb.aux_get(pkg, ["SLOT"]):
-							oldver = x
-					if oldver == None:
-						raise ValueError("could not find old version for package %s" % pkg)
-					oldver = oldver[len(portage.dep_getkey(oldver))+1:]
-					sys.stdout.write("     " + pkg + " (" + oldver + ")\n")
-			else:
-				sys.stdout.write("Nothing to do for this GLSA\n")
-		elif mode == "inject":
-			sys.stdout.write("injecting " + myid + "\n")
-			myglsa.inject()
-		sys.stdout.write("\n")
-	sys.exit(0)
-
-# test is a bit different as Glsa.test() produces no output
-if mode == "test":
-	outputlist = []
-	for myid in glsalist:
-		try:
-			myglsa = Glsa(myid, portage.settings, vardb, portdb)
-		except (GlsaTypeException, GlsaFormatException), e:
-			if verbose:
-				sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
-			continue
-		if myglsa.isVulnerable():
-			outputlist.append(str(myglsa.nr))
-	if len(outputlist) > 0:
-		sys.stderr.write("This system is affected by the following GLSAs:\n")
-		if verbose:
-			summarylist(outputlist)
-		else:
-			sys.stdout.write("\n".join(outputlist)+"\n")
-	else:
-		sys.stderr.write("This system is not affected by any of the listed GLSAs\n")
-	sys.exit(0)
-
-# mail mode as requested by solar
-if mode == "mail":
-	import portage.mail, socket
-	from StringIO import StringIO
-	from email.mime.text import MIMEText
-	
-	# color doesn't make any sense for mail
-	nocolor()
-
-	if "PORTAGE_ELOG_MAILURI" in portage.settings:
-		myrecipient = portage.settings["PORTAGE_ELOG_MAILURI"].split()[0]
-	else:
-		myrecipient = "root@localhost"
-	
-	if "PORTAGE_ELOG_MAILFROM" in portage.settings:
-		myfrom = portage.settings["PORTAGE_ELOG_MAILFROM"]
-	else:
-		myfrom = "glsa-check"
-
-	mysubject = "[glsa-check] Summary for %s" % socket.getfqdn()
-
-	# need a file object for summarylist()
-	myfd = StringIO()
-	myfd.write("GLSA Summary report for host %s\n" % socket.getfqdn())
-	myfd.write("(Command was: %s)\n\n" % " ".join(sys.argv))
-	summarylist(glsalist, fd1=myfd, fd2=myfd)
-	summary = str(myfd.getvalue())
-	myfd.close()
-
-	myattachments = []
-	for myid in glsalist:
-		try:
-			myglsa = Glsa(myid, portage.settings, vardb, portdb)
-		except (GlsaTypeException, GlsaFormatException), e:
-			if verbose:
-				sys.stderr.write(("invalid GLSA: %s (error message was: %s)\n" % (myid, e)))
-			continue
-		myfd = StringIO()
-		myglsa.dump(outstream=myfd)
-		myattachments.append(MIMEText(str(myfd.getvalue()), _charset="utf8"))
-		myfd.close()
-		
-	mymessage = portage.mail.create_message(myfrom, myrecipient, mysubject, summary, myattachments)
-	portage.mail.send_mail(portage.settings, mymessage)
-		
-	sys.exit(0)
-	
-# something wrong here, all valid paths are covered with sys.exit()
-sys.stderr.write("nothing more to do\n")
-sys.exit(2)
diff --git a/pym/portage/_sets/dbapi.py b/pym/portage/_sets/dbapi.py
deleted file mode 100644
index 8fc8c2075..000000000
--- a/pym/portage/_sets/dbapi.py
+++ /dev/null
@@ -1,276 +0,0 @@
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-from portage.versions import catpkgsplit, catsplit, pkgcmp, best
-from portage.dep import Atom
-from portage._sets.base import PackageSet
-from portage._sets import SetConfigError, get_boolean
-
-__all__ = ["CategorySet", "DowngradeSet",
-	"EverythingSet", "OwnerSet", "VariableSet"]
-
-class EverythingSet(PackageSet):
-	_operations = ["merge"]
-	description = "Package set which contains SLOT " + \
-		"atoms to match all installed packages"
-	_filter = None
-
-	def __init__(self, vdbapi):
-		super(EverythingSet, self).__init__()
-		self._db = vdbapi
-
-	def load(self):
-		myatoms = []
-		db_keys = ["SLOT"]
-		aux_get = self._db.aux_get
-		cp_list = self._db.cp_list
-
-		for cp in self._db.cp_all():
-			cpv_list = cp_list(cp)
-
-			if len(cpv_list) > 1:
-				for cpv in cpv_list:
-					slot, = aux_get(cpv, db_keys)
-					atom = Atom("%s:%s" % (cp, slot))
-					if self._filter:
-						if self._filter(atom):
-							myatoms.append(atom)
-					else:
-						myatoms.append(atom)
-
-			else:
-				atom = Atom(cp)
-				if self._filter:
-					if self._filter(atom):
-						myatoms.append(atom)
-				else:
-					myatoms.append(atom)
-
-		self._setAtoms(myatoms)
-	
-	def singleBuilder(self, options, settings, trees):
-		return EverythingSet(trees["vartree"].dbapi)
-	singleBuilder = classmethod(singleBuilder)
-
-class OwnerSet(PackageSet):
-
-	_operations = ["merge", "unmerge"]
-
-	description = "Package set which contains all packages " + \
-		"that own one or more files."
-
-	def __init__(self, vardb=None, files=None):
-		super(OwnerSet, self).__init__()
-		self._db = vardb
-		self._files = files
-
-	def mapPathsToAtoms(self, paths):
-		rValue = set()
-		vardb = self._db
-		aux_get = vardb.aux_get
-		aux_keys = ["SLOT"]
-		for link, p in vardb._owners.iter_owners(paths):
-			cat, pn = catpkgsplit(link.mycpv)[:2]
-			slot, = aux_get(link.mycpv, aux_keys)
-			rValue.add("%s/%s:%s" % (cat, pn, slot))
-		return rValue
-
-	def load(self):
-		self._setAtoms(self.mapPathsToAtoms(self._files))
-
-	def singleBuilder(cls, options, settings, trees):
-		if not "files" in options:
-			raise SetConfigError("no files given")
-
-		import shlex
-		return cls(vardb=trees["vartree"].dbapi,
-			files=frozenset(shlex.split(options["files"])))
-
-	singleBuilder = classmethod(singleBuilder)
-
-class VariableSet(EverythingSet):
-
-	_operations = ["merge", "unmerge"]
-
-	description = "Package set which contains all packages " + \
-		"that match specified values of a specified variable."
-
-	def __init__(self, vardb, metadatadb=None, variable=None, includes=None, excludes=None):
-		super(VariableSet, self).__init__(vardb)
-		self._metadatadb = metadatadb
-		self._variable = variable
-		self._includes = includes
-		self._excludes = excludes
-
-	def _filter(self, atom):
-		ebuild = best(self._metadatadb.match(atom))
-		if not ebuild:
-			return False
-		values, = self._metadatadb.aux_get(ebuild, [self._variable])
-		values = values.split()
-		if self._includes and not self._includes.intersection(values):
-			return False
-		if self._excludes and self._excludes.intersection(values):
-			return False
-		return True
-
-	def singleBuilder(cls, options, settings, trees):
-
-		variable = options.get("variable")
-		if variable is None:
-			raise SetConfigError("missing required attribute: 'variable'")
-
-		includes = options.get("includes", "")
-		excludes = options.get("excludes", "")
-
-		if not (includes or excludes):
-			raise SetConfigError("no includes or excludes given")
-		
-		metadatadb = options.get("metadata-source", "vartree")
-		if not metadatadb in trees.keys():
-			raise SetConfigError("invalid value '%s' for option metadata-source" % metadatadb)
-
-		return cls(trees["vartree"].dbapi,
-			metadatadb=trees[metadatadb].dbapi,
-			excludes=frozenset(excludes.split()),
-			includes=frozenset(includes.split()),
-			variable=variable)
-
-	singleBuilder = classmethod(singleBuilder)
-
-class DowngradeSet(PackageSet):
-
-	_operations = ["merge", "unmerge"]
-
-	description = "Package set which contains all packages " + \
-		"for which the highest visible ebuild version is lower than " + \
-		"the currently installed version."
-
-	def __init__(self, portdb=None, vardb=None):
-		super(DowngradeSet, self).__init__()
-		self._portdb = portdb
-		self._vardb = vardb
-
-	def load(self):
-		atoms = []
-		xmatch = self._portdb.xmatch
-		xmatch_level = "bestmatch-visible"
-		cp_list = self._vardb.cp_list
-		aux_get = self._vardb.aux_get
-		aux_keys = ["SLOT"]
-		for cp in self._vardb.cp_all():
-			for cpv in cp_list(cp):
-				slot, = aux_get(cpv, aux_keys)
-				slot_atom = "%s:%s" % (cp, slot)
-				ebuild = xmatch(xmatch_level, slot_atom)
-				if not ebuild:
-					continue
-				ebuild_split = catpkgsplit(ebuild)[1:]
-				installed_split = catpkgsplit(cpv)[1:]
-				if pkgcmp(installed_split, ebuild_split) > 0:
-					atoms.append(slot_atom)
-
-		self._setAtoms(atoms)
-
-	def singleBuilder(cls, options, settings, trees):
-		return cls(portdb=trees["porttree"].dbapi,
-			vardb=trees["vartree"].dbapi)
-
-	singleBuilder = classmethod(singleBuilder)
-
-class CategorySet(PackageSet):
-	_operations = ["merge", "unmerge"]
-	
-	def __init__(self, category, dbapi, only_visible=True):
-		super(CategorySet, self).__init__()
-		self._db = dbapi
-		self._category = category
-		self._check = only_visible
-		if only_visible:
-			s="visible"
-		else:
-			s="all"
-		self.description = "Package set containing %s packages of category %s" % (s, self._category)
-			
-	def load(self):
-		myatoms = []
-		for cp in self._db.cp_all():
-			if catsplit(cp)[0] == self._category:
-				if (not self._check) or len(self._db.match(cp)) > 0:
-					myatoms.append(cp)
-		self._setAtoms(myatoms)
-	
-	def _builderGetVisible(cls, options):
-		return get_boolean(options, "only_visible", True)
-	_builderGetVisible = classmethod(_builderGetVisible)
-		
-	def singleBuilder(cls, options, settings, trees):
-		if not "category" in options:
-			raise SetConfigError("no category given")
-
-		category = options["category"]
-		if not category in settings.categories:
-			raise SetConfigError("invalid category name '%s'" % category)
-
-		visible = cls._builderGetVisible(options)
-		
-		return CategorySet(category, dbapi=trees["porttree"].dbapi, only_visible=visible)
-	singleBuilder = classmethod(singleBuilder)
-
-	def multiBuilder(cls, options, settings, trees):
-		rValue = {}
-	
-		if "categories" in options:
-			categories = options["categories"].split()
-			invalid = set(categories).difference(settings.categories)
-			if invalid:
-				raise SetConfigError("invalid categories: %s" % ", ".join(list(invalid)))
-		else:
-			categories = settings.categories
-	
-		visible = cls._builderGetVisible(options)
-		name_pattern = options.get("name_pattern", "$category/*")
-	
-		if not "$category" in name_pattern and not "${category}" in name_pattern:
-			raise SetConfigError("name_pattern doesn't include $category placeholder")
-	
-		for cat in categories:
-			myset = CategorySet(cat, trees["porttree"].dbapi, only_visible=visible)
-			myname = name_pattern.replace("$category", cat)
-			myname = myname.replace("${category}", cat)
-			rValue[myname] = myset
-		return rValue
-	multiBuilder = classmethod(multiBuilder)
-
-class AgeSet(EverythingSet):
-	_operations = ["merge", "unmerge"]
-
-	def __init__(self, vardb, mode="older", age=7):
-		super(AgeSet, self).__init__(vardb)
-		self._mode = mode
-		self._age = age
-
-	def _filter(self, atom):
-		import time, os
-	
-		cpv = self._db.match(atom)[0]
-		path = self._db.getpath(cpv, filename="COUNTER")
-		age = (time.time() - os.stat(path).st_mtime) / (3600 * 24)
-		if ((self._mode == "older" and age <= self._age) \
-			or (self._mode == "newer" and age >= self._age)):
-			return False
-		else:
-			return True
-	
-	def singleBuilder(cls, options, settings, trees):
-		mode = options.get("mode", "older")
-		if str(mode).lower() not in ["newer", "older"]:
-			raise SetConfigError("invalid 'mode' value %s (use either 'newer' or 'older')" % mode)
-		try:
-			age = int(options.get("age", "7"))
-		except ValueError, e:
-			raise SetConfigError("value of option 'age' is not an integer")
-		return AgeSet(vardb=trees["vartree"].dbapi, mode=mode, age=age)
-
-	singleBuilder = classmethod(singleBuilder)
diff --git a/pym/portage/_sets/libs.py b/pym/portage/_sets/libs.py
deleted file mode 100644
index 256e7befd..000000000
--- a/pym/portage/_sets/libs.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-from portage._sets.base import PackageSet
-from portage._sets import get_boolean
-from portage.versions import catpkgsplit
-
-class LibraryConsumerSet(PackageSet):
-	_operations = ["merge", "unmerge"]
-
-	def __init__(self, vardbapi, debug=False):
-		super(LibraryConsumerSet, self).__init__()
-		self.dbapi = vardbapi
-		self.debug = debug
-
-	def mapPathsToAtoms(self, paths):
-		rValue = set()
-		for link, p in self.dbapi._owners.iter_owners(paths):
-			cat, pn = catpkgsplit(link.mycpv)[:2]
-			slot = self.dbapi.aux_get(link.mycpv, ["SLOT"])[0]
-			rValue.add("%s/%s:%s" % (cat, pn, slot))
-		return rValue
diff --git a/pym/portage/_sets/security.py b/pym/portage/_sets/security.py
deleted file mode 100644
index a2630fe6f..000000000
--- a/pym/portage/_sets/security.py
+++ /dev/null
@@ -1,89 +0,0 @@
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-import os
-import portage.glsa as glsa
-from portage.util import grabfile, write_atomic
-from portage._sets.base import PackageSet
-from portage.versions import catpkgsplit, pkgcmp
-from portage._sets import get_boolean
-
-__all__ = ["SecuritySet", "NewGlsaSet", "NewAffectedSet", "AffectedSet"]
-
-class SecuritySet(PackageSet):
-	_operations = ["merge"]
-	_skip_applied = False
-	
-	description = "package set that includes all packages possibly affected by a GLSA"
-		
-	def __init__(self, settings, vardbapi, portdbapi, least_change=True):
-		super(SecuritySet, self).__init__()
-		self._settings = settings
-		self._vardbapi = vardbapi
-		self._portdbapi = portdbapi
-		self._least_change = least_change
-
-	def getGlsaList(self, skip_applied):
-		glsaindexlist = glsa.get_glsa_list(self._settings)
-		if skip_applied:
-			applied_list = glsa.get_applied_glsas(self._settings)
-			glsaindexlist = set(glsaindexlist).difference(applied_list)
-			glsaindexlist = list(glsaindexlist)
-		glsaindexlist.sort()
-		return glsaindexlist
-		
-	def load(self):
-		glsaindexlist = self.getGlsaList(self._skip_applied)
-		atomlist = []
-		for glsaid in glsaindexlist:
-			myglsa = glsa.Glsa(glsaid, self._settings, self._vardbapi, self._portdbapi)
-			#print glsaid, myglsa.isVulnerable(), myglsa.isApplied(), myglsa.getMergeList()
-			if self.useGlsa(myglsa):
-				atomlist += ["="+x for x in myglsa.getMergeList(least_change=self._least_change)]
-		self._setAtoms(self._reduce(atomlist))
-	
-	def _reduce(self, atomlist):
-		mydict = {}
-		for atom in atomlist[:]:
-			cpv = self._portdbapi.xmatch("match-all", atom)[0]
-			slot = self._portdbapi.aux_get(cpv, ["SLOT"])[0]
-			cps = "/".join(catpkgsplit(cpv)[0:2]) + ":" + slot
-			if not cps in mydict:
-				mydict[cps] = (atom, cpv)
-			else:
-				other_cpv = mydict[cps][1]
-				if pkgcmp(catpkgsplit(cpv)[1:], catpkgsplit(other_cpv)[1:]) > 0:
-					atomlist.remove(mydict[cps][0])
-					mydict[cps] = (atom, cpv)
-		return atomlist
-	
-	def useGlsa(self, myglsa):
-		return True
-
-	def updateAppliedList(self):
-		glsaindexlist = self.getGlsaList(True)
-		applied_list = glsa.get_applied_glsas(self._settings)
-		for glsaid in glsaindexlist:
-			myglsa = glsa.Glsa(glsaid, self._settings, self._vardbapi, self._portdbapi)
-			if not myglsa.isVulnerable() and not myglsa.nr in applied_list:
-				myglsa.inject()
-	
-	def singleBuilder(cls, options, settings, trees):
-		least_change = not get_boolean(options, "use_emerge_resolver", False)
-		return cls(settings, trees["vartree"].dbapi, trees["porttree"].dbapi, least_change=least_change)
-	singleBuilder = classmethod(singleBuilder)
-	
-class NewGlsaSet(SecuritySet):
-	_skip_applied = True
-	description = "Package set that includes all packages possibly affected by an unapplied GLSA"
-
-class AffectedSet(SecuritySet):
-	description = "Package set that includes all packages affected by an unapplied GLSA"
-
-	def useGlsa(self, myglsa):
-		return myglsa.isVulnerable()
-
-class NewAffectedSet(AffectedSet):
-	_skip_applied = True
-	description = "Package set that includes all packages affected by an unapplied GLSA"
diff --git a/pym/portage/_sets/shell.py b/pym/portage/_sets/shell.py
deleted file mode 100644
index 015c51b92..000000000
--- a/pym/portage/_sets/shell.py
+++ /dev/null
@@ -1,44 +0,0 @@
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-import subprocess
-import os
-
-from portage._sets.base import PackageSet
-from portage._sets import SetConfigError
-
-__all__ = ["CommandOutputSet"]
-
-class CommandOutputSet(PackageSet):
-	"""This class creates a PackageSet from the output of a shell command.
-	   The shell command should produce one atom per line, that is:
-
-	   >>> atom1
-	       atom2
-	       ...
-	       atomN
-
-	   Args:
-	     name: A string that identifies the set.
-	     command: A string or sequence identifying the command to run
-	     (see the subprocess.Popen documentaion for the format)
-	"""
-	_operations = ["merge", "unmerge"]
-
-	def __init__(self, command):
-		super(CommandOutputSet, self).__init__()
-		self._command = command
-		self.description = "Package set generated from output of '%s'" % self._command
-	
-	def load(self):
-		pipe = subprocess.Popen(self._command, stdout=subprocess.PIPE, shell=True)
-		if pipe.wait() == os.EX_OK:
-			text = pipe.stdout.read()
-			self._setAtoms(text.split("\n"))
-		
-	def singleBuilder(self, options, settings, trees):
-		if not "command" in options:
-			raise SetConfigError("no command specified")
-		return CommandOutputSet(options["command"])
-	singleBuilder = classmethod(singleBuilder)
diff --git a/pym/portage/glsa.py b/pym/portage/glsa.py
deleted file mode 100644
index a16b98c2c..000000000
--- a/pym/portage/glsa.py
+++ /dev/null
@@ -1,673 +0,0 @@
-# Copyright 2003-2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-import os
-import sys
-import urllib
-import re
-import xml.dom.minidom
-
-from portage.versions import pkgsplit, catpkgsplit, pkgcmp, best
-from portage.util import grabfile
-from portage.const import CACHE_PATH
-
-# Note: the space for rgt and rlt is important !!
-# FIXME: use slot deps instead, requires GLSA format versioning
-opMapping = {"le": "<=", "lt": "<", "eq": "=", "gt": ">", "ge": ">=", 
-			 "rge": ">=~", "rle": "<=~", "rgt": " >~", "rlt": " <~"}
-NEWLINE_ESCAPE = "!;\\n"	# some random string to mark newlines that should be preserved
-SPACE_ESCAPE = "!;_"		# some random string to mark spaces that should be preserved
-
-def get_applied_glsas(settings):
-	"""
-	Return a list of applied or injected GLSA IDs
-	
-	@type	settings: portage.config
-	@param	settings: portage config instance
-	@rtype:		list
-	@return:	list of glsa IDs
-	"""
-	return grabfile(os.path.join(os.sep, settings["ROOT"], CACHE_PATH.lstrip(os.sep), "glsa"))
-
-
-# TODO: use the textwrap module instead
-def wrap(text, width, caption=""):
-	"""
-	Wraps the given text at column I{width}, optionally indenting
-	it so that no text is under I{caption}. It's possible to encode 
-	hard linebreaks in I{text} with L{NEWLINE_ESCAPE}.
-	
-	@type	text: String
-	@param	text: the text to be wrapped
-	@type	width: Integer
-	@param	width: the column at which the text should be wrapped
-	@type	caption: String
-	@param	caption: this string is inserted at the beginning of the 
-					 return value and the paragraph is indented up to
-					 C{len(caption)}.
-	@rtype:		String
-	@return:	the wrapped and indented paragraph
-	"""
-	rValue = ""
-	line = caption
-	text = text.replace(2*NEWLINE_ESCAPE, NEWLINE_ESCAPE+" "+NEWLINE_ESCAPE)
-	words = text.split()
-	indentLevel = len(caption)+1
-	
-	for w in words:
-		if line != "" and line[-1] == "\n":
-			rValue += line
-			line = " "*indentLevel
-		if len(line)+len(w.replace(NEWLINE_ESCAPE, ""))+1 > width:
-			rValue += line+"\n"
-			line = " "*indentLevel+w.replace(NEWLINE_ESCAPE, "\n")
-		elif w.find(NEWLINE_ESCAPE) >= 0:
-			if len(line.strip()) > 0:
-				rValue += line+" "+w.replace(NEWLINE_ESCAPE, "\n")
-			else:
-				rValue += line+w.replace(NEWLINE_ESCAPE, "\n")
-			line = " "*indentLevel
-		else:
-			if len(line.strip()) > 0:
-				line += " "+w
-			else:
-				line += w
-	if len(line) > 0:
-		rValue += line.replace(NEWLINE_ESCAPE, "\n")
-	rValue = rValue.replace(SPACE_ESCAPE, " ")
-	return rValue
-
-def get_glsa_list(myconfig):
-	"""
-	Returns a list of all available GLSAs in the given repository
-	by comparing the filelist there with the pattern described in
-	the config.
-	
-	@type	myconfig: portage.config
-	@param	myconfig: Portage settings instance
-	
-	@rtype:		List of Strings
-	@return:	a list of GLSA IDs in this repository
-	"""
-	rValue = []
-
-	if "GLSA_DIR" in myconfig:
-		repository = myconfig["GLSA_DIR"]
-	else:
-		repository = os.path.join(myconfig["PORTDIR"], "metadata", "glsa")
-
-	if not os.access(repository, os.R_OK):
-		return []
-	dirlist = os.listdir(repository)
-	prefix = "glsa-"
-	suffix = ".xml"
-	
-	for f in dirlist:
-		try:
-			if f[:len(prefix)] == prefix:
-				rValue.append(f[len(prefix):-1*len(suffix)])
-		except IndexError:
-			pass
-	return rValue
-
-def getListElements(listnode):
-	"""
-	Get all <li> elements for a given <ol> or <ul> node.
-	
-	@type	listnode: xml.dom.Node
-	@param	listnode: <ul> or <ol> list to get the elements for
-	@rtype:		List of Strings
-	@return:	a list that contains the value of the <li> elements
-	"""
-	rValue = []
-	if not listnode.nodeName in ["ul", "ol"]:
-		raise GlsaFormatException("Invalid function call: listnode is not <ul> or <ol>")
-	for li in listnode.childNodes:
-		if li.nodeType != xml.dom.Node.ELEMENT_NODE:
-			continue
-		rValue.append(getText(li, format="strip"))
-	return rValue
-
-def getText(node, format):
-	"""
-	This is the main parser function. It takes a node and traverses
-	recursive over the subnodes, getting the text of each (and the
-	I{link} attribute for <uri> and <mail>). Depending on the I{format}
-	parameter the text might be formatted by adding/removing newlines,
-	tabs and spaces. This function is only useful for the GLSA DTD,
-	it's not applicable for other DTDs.
-	
-	@type	node: xml.dom.Node
-	@param	node: the root node to start with the parsing
-	@type	format: String
-	@param	format: this should be either I{strip}, I{keep} or I{xml}
-					I{keep} just gets the text and does no formatting.
-					I{strip} replaces newlines and tabs with spaces and
-					replaces multiple spaces with one space.
-					I{xml} does some more formatting, depending on the
-					type of the encountered nodes.
-	@rtype:		String
-	@return:	the (formatted) content of the node and its subnodes
-	"""
-	rValue = ""
-	if format in ["strip", "keep"]:
-		if node.nodeName in ["uri", "mail"]:
-			rValue += node.childNodes[0].data+": "+node.getAttribute("link")
-		else:
-			for subnode in node.childNodes:
-				if subnode.nodeName == "#text":
-					rValue += subnode.data
-				else:
-					rValue += getText(subnode, format)
-	else:
-		for subnode in node.childNodes:
-			if subnode.nodeName == "p":
-				for p_subnode in subnode.childNodes:
-					if p_subnode.nodeName == "#text":
-						rValue += p_subnode.data.strip()
-					elif p_subnode.nodeName in ["uri", "mail"]:
-						rValue += p_subnode.childNodes[0].data
-						rValue += " ( "+p_subnode.getAttribute("link")+" )"
-				rValue += NEWLINE_ESCAPE
-			elif subnode.nodeName == "ul":
-				for li in getListElements(subnode):
-					rValue += "-"+SPACE_ESCAPE+li+NEWLINE_ESCAPE+" "
-			elif subnode.nodeName == "ol":
-				i = 0
-				for li in getListElements(subnode):
-					i = i+1
-					rValue += str(i)+"."+SPACE_ESCAPE+li+NEWLINE_ESCAPE+" "
-			elif subnode.nodeName == "code":
-				rValue += getText(subnode, format="keep").replace("\n", NEWLINE_ESCAPE)
-				if rValue[-1*len(NEWLINE_ESCAPE):] != NEWLINE_ESCAPE:
-					rValue += NEWLINE_ESCAPE
-			elif subnode.nodeName == "#text":
-				rValue += subnode.data
-			else:
-				raise GlsaFormatException("Invalid Tag found: ", subnode.nodeName)
-	if format == "strip":
-		rValue = rValue.strip(" \n\t")
-		rValue = re.sub("[\s]{2,}", " ", rValue)
-	return rValue.encode("utf_8")
-
-def getMultiTagsText(rootnode, tagname, format):
-	"""
-	Returns a list with the text of all subnodes of type I{tagname}
-	under I{rootnode} (which itself is not parsed) using the given I{format}.
-	
-	@type	rootnode: xml.dom.Node
-	@param	rootnode: the node to search for I{tagname}
-	@type	tagname: String
-	@param	tagname: the name of the tags to search for
-	@type	format: String
-	@param	format: see L{getText}
-	@rtype:		List of Strings
-	@return:	a list containing the text of all I{tagname} childnodes
-	"""
-	rValue = []
-	for e in rootnode.getElementsByTagName(tagname):
-		rValue.append(getText(e, format))
-	return rValue
-
-def makeAtom(pkgname, versionNode):
-	"""
-	creates from the given package name and information in the 
-	I{versionNode} a (syntactical) valid portage atom.
-	
-	@type	pkgname: String
-	@param	pkgname: the name of the package for this atom
-	@type	versionNode: xml.dom.Node
-	@param	versionNode: a <vulnerable> or <unaffected> Node that
-						 contains the version information for this atom
-	@rtype:		String
-	@return:	the portage atom
-	"""
-	rValue = opMapping[versionNode.getAttribute("range")] \
-				+ pkgname \
-				+ "-" + getText(versionNode, format="strip")
-	try:
-		slot = versionNode.getAttribute("slot").strip()
-	except KeyError:
-		pass
-	else:
-		if slot and slot != "*":
-			rValue += ":" + slot
-	return str(rValue)
-
-def makeVersion(versionNode):
-	"""
-	creates from the information in the I{versionNode} a 
-	version string (format <op><version>).
-	
-	@type	versionNode: xml.dom.Node
-	@param	versionNode: a <vulnerable> or <unaffected> Node that
-						 contains the version information for this atom
-	@rtype:		String
-	@return:	the version string
-	"""
-	rValue = opMapping[versionNode.getAttribute("range")] \
-			+ getText(versionNode, format="strip")
-	try:
-		slot = versionNode.getAttribute("slot").strip()
-	except KeyError:
-		pass
-	else:
-		if slot and slot != "*":
-			rValue += ":" + slot
-	return rValue
-
-def match(atom, dbapi, match_type="default"):
-	"""
-	wrapper that calls revisionMatch() or portage.dbapi.match() depending on 
-	the given atom.
-	
-	@type	atom: string
-	@param	atom: a <~ or >~ atom or a normal portage atom that contains the atom to match against
-	@type	dbapi: portage.dbapi
-	@param	dbapi: one of the portage databases to use as information source
-	@type	match_type: string
-	@param	match_type: if != "default" passed as first argument to dbapi.xmatch 
-				to apply the wanted visibility filters
-	
-	@rtype:		list of strings
-	@return:	a list with the matching versions
-	"""
-	if atom[2] == "~":
-		return revisionMatch(atom, dbapi, match_type=match_type)
-	elif match_type == "default" or not hasattr(dbapi, "xmatch"):
-		return dbapi.match(atom)
-	else:
-		return dbapi.xmatch(match_type, atom)
-
-def revisionMatch(revisionAtom, dbapi, match_type="default"):
-	"""
-	handler for the special >~, >=~, <=~ and <~ atoms that are supposed to behave
-	as > and < except that they are limited to the same version, the range only
-	applies to the revision part.
-	
-	@type	revisionAtom: string
-	@param	revisionAtom: a <~ or >~ atom that contains the atom to match against
-	@type	dbapi: portage.dbapi
-	@param	dbapi: one of the portage databases to use as information source
-	@type	match_type: string
-	@param	match_type: if != "default" passed as first argument to portdb.xmatch 
-				to apply the wanted visibility filters
-	
-	@rtype:		list of strings
-	@return:	a list with the matching versions
-	"""
-	if match_type == "default" or not hasattr(dbapi, "xmatch"):
-		if ":" in revisionAtom:
-			mylist = dbapi.match(re.sub(r'-r[0-9]+(:[^ ]+)?$', r'\1', revisionAtom[2:]))
-		else:
-			mylist = dbapi.match(re.sub("-r[0-9]+$", "", revisionAtom[2:]))
-	else:
-		if ":" in revisionAtom:
-			mylist = dbapi.xmatch(match_type, re.sub(r'-r[0-9]+(:[^ ]+)?$', r'\1', revisionAtom[2:]))
-		else:
-			mylist = dbapi.xmatch(match_type, re.sub("-r[0-9]+$", "", revisionAtom[2:]))
-	rValue = []
-	for v in mylist:
-		r1 = pkgsplit(v)[-1][1:]
-		r2 = pkgsplit(revisionAtom[3:])[-1][1:]
-		if eval(r1+" "+revisionAtom[0:2]+" "+r2):
-			rValue.append(v)
-	return rValue
-		
-
-def getMinUpgrade(vulnerableList, unaffectedList, portdbapi, vardbapi, minimize=True):
-	"""
-	Checks if the systemstate is matching an atom in
-	I{vulnerableList} and returns string describing
-	the lowest version for the package that matches an atom in 
-	I{unaffectedList} and is greater than the currently installed
-	version or None if the system is not affected. Both
-	I{vulnerableList} and I{unaffectedList} should have the
-	same base package.
-	
-	@type	vulnerableList: List of Strings
-	@param	vulnerableList: atoms matching vulnerable package versions
-	@type	unaffectedList: List of Strings
-	@param	unaffectedList: atoms matching unaffected package versions
-	@type	portdbapi:	portage.dbapi.porttree.portdbapi
-	@param	portdbapi:	Ebuild repository
-	@type	vardbapi:	portage.dbapi.vartree.vardbapi
-	@param	vardbapi:	Installed package repository
-	@type	minimize:	Boolean
-	@param	minimize:	True for a least-change upgrade, False for emerge-like algorithm
-	
-	@rtype:		String | None
-	@return:	the lowest unaffected version that is greater than
-				the installed version.
-	"""
-	rValue = None
-	v_installed = []
-	u_installed = []
-	for v in vulnerableList:
-		v_installed += match(v, vardbapi)
-
-	for u in unaffectedList:
-		u_installed += match(u, vardbapi)
-	
-	install_unaffected = True
-	for i in v_installed:
-		if i not in u_installed:
-			install_unaffected = False
-
-	if install_unaffected:
-		return rValue
-	
-	for u in unaffectedList:
-		mylist = match(u, portdbapi, match_type="match-all")
-		for c in mylist:
-			c_pv = catpkgsplit(c)
-			i_pv = catpkgsplit(best(v_installed))
-			if pkgcmp(c_pv[1:], i_pv[1:]) > 0 \
-					and (rValue == None \
-						or not match("="+rValue, portdbapi) \
-						or (minimize ^ (pkgcmp(c_pv[1:], catpkgsplit(rValue)[1:]) > 0)) \
-							and match("="+c, portdbapi)) \
-					and portdbapi.aux_get(c, ["SLOT"]) == vardbapi.aux_get(best(v_installed), ["SLOT"]):
-				rValue = c_pv[0]+"/"+c_pv[1]+"-"+c_pv[2]
-				if c_pv[3] != "r0":		# we don't like -r0 for display
-					rValue += "-"+c_pv[3]
-	return rValue
-
-def format_date(datestr):
-	"""
-	Takes a date (announced, revised) date from a GLSA and formats
-	it as readable text (i.e. "January 1, 2008").
-	
-	@type	date: String
-	@param	date: the date string to reformat
-	@rtype:		String
-	@return:	a reformatted string, or the original string
-				if it cannot be reformatted.
-	"""
-	splitdate = datestr.split("-", 2)
-	if len(splitdate) != 3:
-		return datestr
-	
-	# This cannot raise an error as we use () instead of []
-	splitdate = (int(x) for x in splitdate)
-	
-	from datetime import date
-	try:
-		d = date(*splitdate)
-	except ValueError:
-		return datestr
-	
-	# TODO We could format to local date format '%x' here?
-	return d.strftime("%B %d, %Y")
-
-# simple Exception classes to catch specific errors
-class GlsaTypeException(Exception):
-	def __init__(self, doctype):
-		Exception.__init__(self, "wrong DOCTYPE: %s" % doctype)
-
-class GlsaFormatException(Exception):
-	pass
-				
-class GlsaArgumentException(Exception):
-	pass
-
-# GLSA xml data wrapper class
-class Glsa:
-	"""
-	This class is a wrapper for the XML data and provides methods to access
-	and display the contained data.
-	"""
-	def __init__(self, myid, myconfig, vardbapi, portdbapi):
-		"""
-		Simple constructor to set the ID, store the config and gets the 
-		XML data by calling C{self.read()}.
-		
-		@type	myid: String
-		@param	myid: String describing the id for the GLSA object (standard
-					  GLSAs have an ID of the form YYYYMM-nn) or an existing
-					  filename containing a GLSA.
-		@type	myconfig: portage.config
-		@param	myconfig: the config that should be used for this object.
-		@type	vardbapi: portage.dbapi.vartree.vardbapi
-		@param	vardbapi: installed package repository
-		@type	portdbapi: portage.dbapi.porttree.portdbapi
-		@param	portdbapi: ebuild repository
-		"""
-		if re.match(r'\d{6}-\d{2}', myid):
-			self.type = "id"
-		elif os.path.exists(myid):
-			self.type = "file"
-		else:
-			raise GlsaArgumentException("Given ID "+myid+" isn't a valid GLSA ID or filename.")
-		self.nr = myid
-		self.config = myconfig
-		self.vardbapi = vardbapi
-		self.portdbapi = portdbapi
-		self.read()
-
-	def read(self):
-		"""
-		Here we build the filename from the config and the ID and pass
-		it to urllib to fetch it from the filesystem or a remote server.
-		
-		@rtype:		None
-		@return:	None
-		"""
-		if "GLSA_DIR" in self.config:
-			repository = "file://" + self.config["GLSA_DIR"]+"/"
-		else:
-			repository = "file://" + self.config["PORTDIR"] + "/metadata/glsa/"
-		if self.type == "file":
-			myurl = "file://"+self.nr
-		else:
-			myurl = repository + "glsa-%s.xml" % str(self.nr)
-		self.parse(urllib.urlopen(myurl))
-		return None
-
-	def parse(self, myfile):
-		"""
-		This method parses the XML file and sets up the internal data 
-		structures by calling the different helper functions in this
-		module.
-		
-		@type	myfile: String
-		@param	myfile: Filename to grab the XML data from
-		@rtype:		None
-		@returns:	None
-		"""
-		self.DOM = xml.dom.minidom.parse(myfile)
-		if not self.DOM.doctype:
-			raise GlsaTypeException(None)
-		elif self.DOM.doctype.systemId == "http://www.gentoo.org/dtd/glsa.dtd":
-			self.dtdversion = 0
-		elif self.DOM.doctype.systemId == "http://www.gentoo.org/dtd/glsa-2.dtd":
-			self.dtdversion = 2
-		else:
-			raise GlsaTypeException(self.DOM.doctype.systemId)
-		myroot = self.DOM.getElementsByTagName("glsa")[0]
-		if self.type == "id" and myroot.getAttribute("id") != self.nr:
-			raise GlsaFormatException("filename and internal id don't match:" + myroot.getAttribute("id") + " != " + self.nr)
-
-		# the simple (single, required, top-level, #PCDATA) tags first
-		self.title = getText(myroot.getElementsByTagName("title")[0], format="strip")
-		self.synopsis = getText(myroot.getElementsByTagName("synopsis")[0], format="strip")
-		self.announced = format_date(getText(myroot.getElementsByTagName("announced")[0], format="strip"))
-		
-		count = 1
-		# Support both formats of revised:
-		# <revised>December 30, 2007: 02</revised>
-		# <revised count="2">2007-12-30</revised>
-		revisedEl = myroot.getElementsByTagName("revised")[0]
-		self.revised = getText(revisedEl, format="strip")
-		if (revisedEl.attributes.has_key("count")):
-			count = revisedEl.getAttribute("count")
-		elif (self.revised.find(":") >= 0):
-			(self.revised, count) = self.revised.split(":")
-		
-		self.revised = format_date(self.revised)
-		
-		try:
-			self.count = int(count)
-		except ValueError:
-			# TODO should this rais a GlsaFormatException?
-			self.count = 1
-		
-		# now the optional and 0-n toplevel, #PCDATA tags and references
-		try:
-			self.access = getText(myroot.getElementsByTagName("access")[0], format="strip")
-		except IndexError:
-			self.access = ""
-		self.bugs = getMultiTagsText(myroot, "bug", format="strip")
-		self.references = getMultiTagsText(myroot.getElementsByTagName("references")[0], "uri", format="keep")
-		
-		# and now the formatted text elements
-		self.description = getText(myroot.getElementsByTagName("description")[0], format="xml")
-		self.workaround = getText(myroot.getElementsByTagName("workaround")[0], format="xml")
-		self.resolution = getText(myroot.getElementsByTagName("resolution")[0], format="xml")
-		self.impact_text = getText(myroot.getElementsByTagName("impact")[0], format="xml")
-		self.impact_type = myroot.getElementsByTagName("impact")[0].getAttribute("type")
-		try:
-			self.background = getText(myroot.getElementsByTagName("background")[0], format="xml")
-		except IndexError:
-			self.background = ""					
-
-		# finally the interesting tags (product, affected, package)
-		self.glsatype = myroot.getElementsByTagName("product")[0].getAttribute("type")
-		self.product = getText(myroot.getElementsByTagName("product")[0], format="strip")
-		self.affected = myroot.getElementsByTagName("affected")[0]
-		self.packages = {}
-		for p in self.affected.getElementsByTagName("package"):
-			name = p.getAttribute("name")
-			if name not in self.packages:
-				self.packages[name] = []
-			tmp = {}
-			tmp["arch"] = p.getAttribute("arch")
-			tmp["auto"] = (p.getAttribute("auto") == "yes")
-			tmp["vul_vers"] = [makeVersion(v) for v in p.getElementsByTagName("vulnerable")]
-			tmp["unaff_vers"] = [makeVersion(v) for v in p.getElementsByTagName("unaffected")]
-			tmp["vul_atoms"] = [makeAtom(name, v) for v in p.getElementsByTagName("vulnerable")]
-			tmp["unaff_atoms"] = [makeAtom(name, v) for v in p.getElementsByTagName("unaffected")]
-			self.packages[name].append(tmp)
-		# TODO: services aren't really used yet
-		self.services = self.affected.getElementsByTagName("service")
-		return None
-
-	def dump(self, outstream=sys.stdout):
-		"""
-		Dumps a plaintext representation of this GLSA to I{outfile} or 
-		B{stdout} if it is ommitted. You can specify an alternate
-		I{encoding} if needed (default is latin1).
-		
-		@type	outstream: File
-		@param	outfile: Stream that should be used for writing
-						 (defaults to sys.stdout)
-		"""
-		width = 76
-		outstream.write(("GLSA %s: \n%s" % (self.nr, self.title)).center(width)+"\n")
-		outstream.write((width*"=")+"\n")
-		outstream.write(wrap(self.synopsis, width, caption="Synopsis:         ")+"\n")
-		outstream.write("Announced on:      %s\n" % self.announced)
-		outstream.write("Last revised on:   %s : %02d\n\n" % (self.revised, self.count))
-		if self.glsatype == "ebuild":
-			for k in self.packages.keys():
-				pkg = self.packages[k]
-				for path in pkg:
-					vul_vers = "".join(path["vul_vers"])
-					unaff_vers = "".join(path["unaff_vers"])
-					outstream.write("Affected package:  %s\n" % k)
-					outstream.write("Affected archs:    ")
-					if path["arch"] == "*":
-						outstream.write("All\n")
-					else:
-						outstream.write("%s\n" % path["arch"])
-					outstream.write("Vulnerable:        %s\n" % vul_vers)
-					outstream.write("Unaffected:        %s\n\n" % unaff_vers)
-		elif self.glsatype == "infrastructure":
-			pass
-		if len(self.bugs) > 0:
-			outstream.write("\nRelated bugs:      ")
-			for i in range(0, len(self.bugs)):
-				outstream.write(self.bugs[i])
-				if i < len(self.bugs)-1:
-					outstream.write(", ")
-				else:
-					outstream.write("\n")				
-		if self.background:
-			outstream.write("\n"+wrap(self.background, width, caption="Background:       "))
-		outstream.write("\n"+wrap(self.description, width, caption="Description:      "))
-		outstream.write("\n"+wrap(self.impact_text, width, caption="Impact:           "))
-		outstream.write("\n"+wrap(self.workaround, width, caption="Workaround:       "))
-		outstream.write("\n"+wrap(self.resolution, width, caption="Resolution:       "))
-		myreferences = ""
-		for r in self.references:
-			myreferences += (r.replace(" ", SPACE_ESCAPE)+NEWLINE_ESCAPE+" ")
-		outstream.write("\n"+wrap(myreferences, width, caption="References:       "))
-		outstream.write("\n")
-	
-	def isVulnerable(self):
-		"""
-		Tests if the system is affected by this GLSA by checking if any
-		vulnerable package versions are installed. Also checks for affected
-		architectures.
-		
-		@rtype:		Boolean
-		@returns:	True if the system is affected, False if not
-		"""
-		rValue = False
-		for k in self.packages.keys():
-			pkg = self.packages[k]
-			for path in pkg:
-				if path["arch"] == "*" or self.config["ARCH"] in path["arch"].split():
-					for v in path["vul_atoms"]:
-						rValue = rValue \
-							or (len(match(v, self.vardbapi)) > 0 \
-								and getMinUpgrade(path["vul_atoms"], path["unaff_atoms"], \
-										self.portdbapi, self.vardbapi))
-		return rValue
-	
-	def isApplied(self):
-		"""
-		Looks if the GLSA IDis in the GLSA checkfile to check if this
-		GLSA was already applied.
-		
-		@rtype:		Boolean
-		@returns:	True if the GLSA was applied, False if not
-		"""
-		return (self.nr in get_applied_glsas(self.config))
-
-	def inject(self):
-		"""
-		Puts the ID of this GLSA into the GLSA checkfile, so it won't
-		show up on future checks. Should be called after a GLSA is 
-		applied or on explicit user request.
-
-		@rtype:		None
-		@returns:	None
-		"""
-		if not self.isApplied():
-			checkfile = open(os.path.join(os.sep, self.config["ROOT"], CACHE_PATH.lstrip(os.sep), "glsa"), "a+")
-			checkfile.write(self.nr+"\n")
-			checkfile.close()
-		return None
-	
-	def getMergeList(self, least_change=True):
-		"""
-		Returns the list of package-versions that have to be merged to
-		apply this GLSA properly. The versions are as low as possible 
-		while avoiding downgrades (see L{getMinUpgrade}).
-		
-		@type	least_change: Boolean
-		@param	least_change: True if the smallest possible upgrade should be selected,
-					False for an emerge-like algorithm
-		@rtype:		List of Strings
-		@return:	list of package-versions that have to be merged
-		"""
-		rValue = []
-		for pkg in self.packages.keys():
-			for path in self.packages[pkg]:
-				update = getMinUpgrade(path["vul_atoms"], path["unaff_atoms"], \
-					self.portdbapi, self.vardbapi, minimize=least_change)
-				if update:
-					rValue.append(update)
-		return rValue
diff --git a/pym/portage/tests/sets/__init__.py b/pym/portage/tests/sets/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/pym/portage/tests/sets/__init__.py
+++ /dev/null
diff --git a/pym/portage/tests/sets/files/__init__.py b/pym/portage/tests/sets/files/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/pym/portage/tests/sets/files/__init__.py
+++ /dev/null
diff --git a/pym/portage/tests/sets/files/__test__ b/pym/portage/tests/sets/files/__test__
deleted file mode 100644
index e69de29bb..000000000
--- a/pym/portage/tests/sets/files/__test__
+++ /dev/null
diff --git a/pym/portage/tests/sets/files/testConfigFileSet.py b/pym/portage/tests/sets/files/testConfigFileSet.py
deleted file mode 100644
index c8aea5076..000000000
--- a/pym/portage/tests/sets/files/testConfigFileSet.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# testConfigFileSet.py -- Portage Unit Testing Functionality
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id: testShell.py 7363 2007-07-22 23:21:14Z zmedico $
-
-import tempfile, os
-
-from portage.tests import TestCase, test_cps
-from portage._sets.files import ConfigFileSet
-
-class ConfigFileSetTestCase(TestCase):
-	"""Simple Test Case for ConfigFileSet"""
-
-	def setUp(self):
-		fd, self.testfile = tempfile.mkstemp(suffix=".testdata", prefix=self.__class__.__name__, text=True)
-		for i in range(0, len(test_cps)):
-			atom = test_cps[i]
-			if i % 2 == 0:
-				os.write(fd, atom+" abc def"+"\n")
-			else:
-				os.write(fd, atom+"\n")
-		os.close(fd)
-
-	def tearDown(self):
-		os.unlink(self.testfile)
-
-	def testConfigStaticFileSet(self):
-		s = ConfigFileSet(self.testfile)
-		s.load()
-		self.assertEqual(set(test_cps), s.getAtoms())
-
diff --git a/pym/portage/tests/sets/files/testStaticFileSet.py b/pym/portage/tests/sets/files/testStaticFileSet.py
deleted file mode 100644
index 3613bb157..000000000
--- a/pym/portage/tests/sets/files/testStaticFileSet.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# testStaticFileSet.py -- Portage Unit Testing Functionality
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id: testShell.py 7363 2007-07-22 23:21:14Z zmedico $
-
-import tempfile, os
-
-from portage.tests import TestCase, test_cps
-from portage._sets.files import StaticFileSet
-from portage.env.loaders import TestTextLoader
-from portage.env.config import ConfigLoaderKlass
-
-class StaticFileSetTestCase(TestCase):
-	"""Simple Test Case for StaticFileSet"""
-
-	def setUp(self):
-		fd, self.testfile = tempfile.mkstemp(suffix=".testdata", prefix=self.__class__.__name__, text=True)
-		os.write(fd, "\n".join(test_cps))
-		os.close(fd)
-
-	def tearDown(self):
-		os.unlink(self.testfile)
-
-	def testSampleStaticFileSet(self):
-		s = StaticFileSet(self.testfile)
-		s.load()
-		self.assertEqual(set(test_cps), s.getAtoms())
-
diff --git a/pym/portage/tests/sets/shell/__init__.py b/pym/portage/tests/sets/shell/__init__.py
deleted file mode 100644
index e69de29bb..000000000
--- a/pym/portage/tests/sets/shell/__init__.py
+++ /dev/null
diff --git a/pym/portage/tests/sets/shell/__test__ b/pym/portage/tests/sets/shell/__test__
deleted file mode 100644
index e69de29bb..000000000
--- a/pym/portage/tests/sets/shell/__test__
+++ /dev/null
diff --git a/pym/portage/tests/sets/shell/testShell.py b/pym/portage/tests/sets/shell/testShell.py
deleted file mode 100644
index f8982575a..000000000
--- a/pym/portage/tests/sets/shell/testShell.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# testCommandOututSet.py -- Portage Unit Testing Functionality
-# Copyright 2007 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-# $Id$
-
-from portage.process import find_binary
-from portage.tests import TestCase, test_cps
-from portage._sets.shell import CommandOutputSet
-
-class CommandOutputSetTestCase(TestCase):
-	"""Simple Test Case for CommandOutputSet"""
-
-	def setUp(self):
-		pass
-
-	def tearDown(self):
-		pass
-
-	def testCommand(self):
-		
-		input = set(test_cps)
-		command = find_binary("bash")
-		command += " -c '"
-		for a in input:
-		  command += " echo -e \"%s\" ; " % a
-		command += "'"
-		s = CommandOutputSet(command)
-		atoms = s.getAtoms()
-		self.assertEqual(atoms, input)