Attachment #96849 for bug #6411




# portage_sets.py - Portage Sets functionality
# Copyright 2006 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Id: $

import os

from portage_dep import isvalidatom
from portage_const import SET_PATH, WORLD_FILE

class PackageSet(list):
	""" Abstract PackageSet Class 
	Ironically this is a python list and NOT a set, as we need to preserve
	order here.
	"""
	
	def __init__( self ):
		""" All PackageSet classes have items """
		self.items = None

def PackageSetFactory( set_name, root="/", settings=None ):
	""" Give me a valid set_name and I'll make you the right one.
	    (settings,root) are require for certain types of Sets (glsa,all,system)  """

	if os.path.exists( SET_PATH + os.sep + set_name ):
		return PackageSetFile( SET_PATH + os.sep + set_name )
	elif set_name in "world":
		return WorldSet( root )
	elif not settings:
		raise ValueError( "Settings is require for sets: %s" % ["system","all","glsa"] )
	elif set_name in "system":
		return SystemSet( settings )
	elif set_name in "all":
		return AllSet( root, settings )
	elif set_name in "glsa":
		return GLSASet( settings )
	else:
		return PackageSetFile( set_name )

class AllSet(PackageSet):
	""" Returns a set of all installed packages (CPs) """
	
	def __init__( self, root, settings ):
		""" Pass me a config to work with. """
		from portage import vartree
		vartree = vartree( root=root, settings=settings )
		self.items = vartree.dbapi.cp_all()

class SystemSet(PackageSet):
	""" Returns a set of all packages in 'system' """
	
	def __init__( self, settings ):
		""" I need a config object to inspect.  """
		# settings.packages all start with "*", so we strip it here.
		self.items = [item[1:] for item in settings.packages]

class PackageSetList(PackageSet):
	""" Represents a set of packages """

	def __init__( self, cpvs ):
		""" Create a new object given a list of atoms (cps or cpvs) """
		self.items = cpvs

class WorldSet(PackageSet):
	""" Represents everything in "world", aka installed manually by the user. """
	
	def __init__( self, root ):
		""" Create a new object given a root to pull from. """
		self.items = PackageSetFile( root + WORLD_FILE ).items

class GLSASet(PackageSet):
	""" Represents a set of packages worth upgrading for security reasons """
	
	def __init__( self, root ):
		raise NotImplementedError("GLSA Set is not written yet")

class PackageSetFile(PackageSet):
	""" Represents a set of packages loaded from a file"""
	
	def __init__( self, filename ):
		""" Create a new object given a filename to load a set from """
		handle = open(filename, "r")	
		items = handle.readlines()
		items = [l for l in items if not l.startswith("#")]
		items = [item.rstrip() for item in items]
		items = [pkg for pkg in items if isvalidatom(pkg)]
		self.items = items
		self.filename = filename

Lines 14-19 Link Here

(-)pym/portage_const.py (+1 lines)
14	DEPCACHE_PATH = CACHE_PATH+"/dep"	14	DEPCACHE_PATH = CACHE_PATH+"/dep"
15		15
16	USER_CONFIG_PATH = "/etc/portage"	16	USER_CONFIG_PATH = "/etc/portage"
		17	SET_PATH = USER_CONFIG_PATH+"/sets"
17	MODULES_FILE_PATH = USER_CONFIG_PATH+"/modules"	18	MODULES_FILE_PATH = USER_CONFIG_PATH+"/modules"
18	CUSTOM_PROFILE_PATH = USER_CONFIG_PATH+"/profile"	19	CUSTOM_PROFILE_PATH = USER_CONFIG_PATH+"/profile"
19		20

Lines 40-45 Link Here

(-)bin/emerge (-71 / +119 lines)
40	import portage_locks	40	import portage_locks
41	import portage_exception	41	import portage_exception
42	from portage_data import secpass	42	from portage_data import secpass
		43	from portage_const import SET_PATH
		44	from portage_sets import PackageSetFactory
43		45
44	if not hasattr(__builtins__, "set"):	46	if not hasattr(__builtins__, "set"):
45	from sets import Set as set	47	from sets import Set as set
Lines 178-184 Link Here
178	"clean", "config", "depclean",	180	"clean", "config", "depclean",
179	"info", "metadata",	181	"info", "metadata",
180	"prune", "regen", "search",	182	"prune", "regen", "search",
181	"sync", "system", "unmerge", "world",	183	"sync", "unmerge",
182	]	184	]
183	options=[	185	options=[
184	"--ask", "--alphabetical",	186	"--ask", "--alphabetical",
Lines 348-362 Link Here
348	#configure emerge engine parameters	350	#configure emerge engine parameters
349	#	351	#
350	# self: include _this_ package regardless of if it is merged.	352	# self: include _this_ package regardless of if it is merged.
351	# selective: exclude the package if it is merged	353	# selective: exclude the package if it is merged.
352	# recurse: go into the dependencies	354	# recurse: go into the dependencies
353	# deep: go into the dependencies of already merged packages	355	# deep: go into the dependencies of already merged packages
354	# empty: pretend nothing is merged	356	# empty: pretend nothing is merged
355	myparams=["self","recurse"]	357	myparams=["self","recurse"]
356	add=[]	358	add=[]
357	sub=[]	359	sub=[]
358	if "--update" in myopts or myaction in ("system", "world"):	360	if "--update" in myopts:
359	add.extend(["selective","empty"])	361	add.extend(["selective","empty"])
		362	if "--package-set" in myopts:
		363	add.extend(["selective"])
360	if "--emptytree" in myopts:	364	if "--emptytree" in myopts:
361	add.extend(["empty"])	365	add.extend(["empty"])
362	sub.extend(["selective"])	366	sub.extend(["selective"])
Lines 368-375 Link Here
368	add.extend(["deep"])	372	add.extend(["deep"])
369	if "--selective" in myopts:	373	if "--selective" in myopts:
370	add.extend(["selective"])	374	add.extend(["selective"])
371	if myaction in ["world","system"]:
372	add.extend(["selective"])
373	elif myaction in ["depclean"]:	375	elif myaction in ["depclean"]:
374	add.extend(["empty"])	376	add.extend(["empty"])
375	sub.extend(["selective"])	377	sub.extend(["selective"])
Lines 1226-1281 Link Here
1226	retlist.append(y)	1228	retlist.append(y)
1227	return retlist	1229	return retlist
1228		1230
1229	def xcreate(self,mode="system"):	1231	def setCreate( self, set_name ):
1230	world_problems = False	1232	"""
1231	if mode=="system":	1233	Checks dependencies on all sets (system + world)
1232	mylist = getlist(self.settings, "system")	1234	Replaces xcreate()
1233	else:
1234	#world mode
1235	worldlist = getlist(self.settings, "world")
1236	sysdict = genericdict(getlist(self.settings, "system"))
1237	worlddict=genericdict(worldlist)
1238		1235
1239	for x in worlddict.keys():	1236	@param set_name: Name of item to merge.
1240	if not portage.isvalidatom(x):	1237	@type set_name: String
1241	world_problems = True	1238	@rtype: bool
1242	elif not self.trees[self.target_root]["vartree"].dbapi.match(x):	1239	@returns: True if set exists and has proper deps, false if improper deps
1243	world_problems = True	1240	and raises ParseError if set_name is not a set.
1244	else:
1245	sysdict[x]=worlddict[x]
1246		1241
1247	mylist = sysdict.keys()	1242	"""
1248		1243
1249	newlist = []	1244	try:
1250	for atom in mylist:	1245	_set = PackageSetFactory( set_name, self.target_root, self.settings )
1251	if portage.dep_getkey(atom).split("/")[-1] == "portage":	1246	except IOError:
1252	newlist.insert(0, atom)	1247	error = portage_exception.ParseError("%s is not a set" % set_name)
1253	else:	1248	error.pkg = set_name
1254	newlist.append(atom)	1249	raise error
1255	mylist = newlist	1250
1256
1257	missing_atoms = []	1251	missing_atoms = []
1258	for mydep in mylist:	1252	for pkg in _set.items:
1259	try:	1253	try:
1260	if not self.select_dep(	1254	if not self.select_dep(
1261	self.target_root, mydep, raise_on_missing=True):	1255	self.target_root, pkg, raise_on_missing=True):
1262	print "\n\n!!! Problem resolving dependencies for", mydep	1256	portage.writemsg_stdout( "\n!!! Problem resolving dependencies for %s" % mydep )
1263	return 0	1257	return 0
1264	except ValueError:	1258	except ValueError:
1265	missing_atoms.append(mydep)	1259	missing_atoms.append(pkg)
1266
1267	if world_problems:
1268	print "\n!!! Problems have been detected with your world file"
1269	print "!!! Please run "+green("emaint --check world")+"\n"
1270
1271	if missing_atoms:	1260	if missing_atoms:
1272	print "\n" + colorize("BAD", "!!!") + \	1261	portage.writemsg_stdout( "\n" + colorize("BAD", "!!!") + \
1273	" Ebuilds for the following packages are either all"	1262	" Ebuilds for the following packages are either all\n")
1274	print colorize("BAD", "!!!") + " masked or don't exist:"	1263	portage.writemsg_stdout( colorize("BAD", "!!!") + " masked or don't exist:")
1275	print " ".join(missing_atoms) + "\n"	1264	portage.writemsg_stdout( colorize("BAD", "\n!!!").join( missing_atoms) + "\n")
1276		1265
1277	return 1	1266	return 1
1278		1267
		1268	def xcreate(self,mode="system"):
		1269
		1270	if False:
		1271	world_problems = False
		1272	if mode=="system":
		1273	mylist = getlist(self.settings, "system")
		1274	else:
		1275	#world mode
		1276	worldlist = getlist(self.settings, "world")
		1277	sysdict = genericdict(getlist(self.settings, "system"))
		1278	worlddict=genericdict(worldlist)
		1279
		1280	for x in worlddict.keys():
		1281	if not portage.isvalidatom(x):
		1282	world_problems = True
		1283	elif not self.trees[self.target_root]["vartree"].dbapi.match(x):
		1284	world_problems = True
		1285	else:
		1286	sysdict[x]=worlddict[x]
		1287
		1288	mylist = sysdict.keys()
		1289
		1290	newlist = []
		1291	for atom in mylist:
		1292	if portage.dep_getkey(atom).split("/")[-1] == "portage":
		1293	newlist.insert(0, atom)
		1294	else:
		1295	newlist.append(atom)
		1296	mylist = newlist
		1297
		1298	missing_atoms = []
		1299	for mydep in mylist:
		1300	try:
		1301	if not self.select_dep(
		1302	self.target_root, mydep, raise_on_missing=True):
		1303	print "\n\n!!! Problem resolving dependencies for", mydep
		1304	return 0
		1305	except ValueError:
		1306	missing_atoms.append(mydep)
		1307
		1308	if world_problems:
		1309	print "\n!!! Problems have been detected with your world file"
		1310	print "!!! Please run "+green("emaint --check world")+"\n"
		1311
		1312	if missing_atoms:
		1313	print "\n" + colorize("BAD", "!!!") + \
		1314	" Ebuilds for the following packages are either all"
		1315	print colorize("BAD", "!!!") + " masked or don't exist:"
		1316	print " ".join(missing_atoms) + "\n"
		1317
		1318	return 1
		1319	else:
		1320	raise NotImplementedError("Xcreate is depreated")
		1321
1279	def match(self, mydep, myroot=None, mykey=None):	1322	def match(self, mydep, myroot=None, mykey=None):
1280	# support mutual exclusive deps	1323	# support mutual exclusive deps
1281	if myroot is None:	1324	if myroot is None:
Lines 2208-2213 Link Here
2208		2251
2209	mysettings = portage.config(clone=settings)	2252	mysettings = portage.config(clone=settings)
2210		2253
		2254	### XXX Fix unmerge logic to work with sets ?
		2255
2211	if not unmerge_files or "world" in unmerge_files or "system" in unmerge_files:	2256	if not unmerge_files or "world" in unmerge_files or "system" in unmerge_files:
2212	if "unmerge"==unmerge_action:	2257	if "unmerge"==unmerge_action:
2213	print	2258	print
Lines 3047-3052 Link Here
3047	print "\n error processing %(cpv)s, continuing... (%(e)s)" % {"cpv":y,"e":str(e)}	3092	print "\n error processing %(cpv)s, continuing... (%(e)s)" % {"cpv":y,"e":str(e)}
3048	print "done!"	3093	print "done!"
3049		3094
		3095	### XXX Fix config to not take sets
		3096
3050	def action_config(settings, trees, myopts, myfiles):	3097	def action_config(settings, trees, myopts, myfiles):
3051	if len(myfiles) != 1 or "system" in myfiles or "world" in myfiles:	3098	if len(myfiles) != 1 or "system" in myfiles or "world" in myfiles:
3052	print red("!!! config can only take a single package atom at this time\n")	3099	print red("!!! config can only take a single package atom at this time\n")
Lines 3308-3316 Link Here
3308	myvarlist = vardb.cpv_all()	3355	myvarlist = vardb.cpv_all()
3309		3356
3310	if not syslist:	3357	if not syslist:
3311	print "\n!!! You have no system list.",	3358	print "\n!!! You have no system set.",
3312	if not worldlist:	3359	if not worldlist:
3313	print "\n!!! You have no world file.",	3360	print "\n!!! You have no world set.",
3314	if not myvarlist:	3361	if not myvarlist:
3315	print "\n!!! You have no installed package database (%s)." % portage.VDB_PATH,	3362	print "\n!!! You have no installed package database (%s)." % portage.VDB_PATH,
3316		3363
Lines 3447-3485 Link Here
3447	print darkgreen("emerge: It seems we have nothing to resume...")	3494	print darkgreen("emerge: It seems we have nothing to resume...")
3448	sys.exit(0)	3495	sys.exit(0)
3449		3496
		3497
		3498	""" Here we parse the command line args, we try sets first, then
		3499	normal packages.
		3500	"""
		3501
3450	myparams = create_depgraph_params(myopts, myaction)	3502	myparams = create_depgraph_params(myopts, myaction)
3451	mydepgraph = depgraph(settings, trees,	3503	mydepgraph = depgraph(settings, trees,
3452	myopts, myparams, spinner)	3504	myopts, myparams, spinner)
3453	if myaction in ["system","world"]:	3505
3454	if not ("--quiet" in myopts):	3506	mypackages = []
3455	print "Calculating",myaction,"dependencies ",	3507	unfulfilled_sets = []
3456	sys.stdout.flush()	3508	sets = myfiles
3457	if not mydepgraph.xcreate(myaction):	3509	portage.writemsg_stdout( "\nCalculating dependencies: " )
3458	print "!!! Depgraph creation failed."	3510
3459	sys.exit(1)	3511	for p_set in sets:
3460	if not ("--quiet" in myopts):
3461	print "\b\b... done!"
3462	else:
3463	if not ("--quiet" in myopts):
3464	print "Calculating dependencies ",
3465	sys.stdout.flush()
3466	try:	3512	try:
3467	retval, favorites = mydepgraph.select_files(myfiles)	3513	if not mydepgraph.setCreate(p_set):
		3514	unfulfilled_sets.append(p_set)
		3515	except portage_exception.ParseError, pe:
		3516	mypackages.append( pe.pkg )
		3517	if unfulfilled_sets:
		3518	raise Exception( "Depgraph creation failed for: %s" % unfulfilled_sets )
		3519	elif mypackages:
		3520	try:
		3521	retval, favorites = mydepgraph.select_files(mypackages)
3468	except portage_exception.PackageNotFound, e:	3522	except portage_exception.PackageNotFound, e:
3469	portage.writemsg("\n!!! %s\n" % str(e), noiselevel=-1)	3523	portage.writemsg("\n!!! %s\n" % str(e), noiselevel=-1)
3470	sys.exit(1)	3524	sys.exit(1)
3471	if not retval:	3525	if not retval:
3472	sys.exit(1)	3526	sys.exit(1)
3473	if not ("--quiet" in myopts):	3527	if not ("--quiet" in myopts):
3474	print "\b\b... done!"	3528	portage.writemsg( "\b\b... done!" )
3475		3529
3476	if ("--usepkgonly" in myopts) and mydepgraph.missingbins:	3530	if ("--usepkgonly" in myopts) and mydepgraph.missingbins:
3477	sys.stderr.write(red("The following binaries are not available for merging...\n"))	3531	portage.writemsg_stderr(red("The following binaries are not available for merging...\n"))
3478		3532
3479	if mydepgraph.missingbins:	3533	if mydepgraph.missingbins:
3480	for x in mydepgraph.missingbins:	3534	for x in mydepgraph.missingbins:
3481	sys.stderr.write(" "+str(x)+"\n")	3535	portage.writemsg_stderr(" "+str(x)+"\n")
3482	sys.stderr.write("\nThese are required by '--usepkgonly' -- Terminating.\n\n")	3536	portage.writemsg_stderr("\nThese are required by '--usepkgonly' -- Terminating.\n\n")
3483	sys.exit(1)	3537	sys.exit(1)
3484		3538
3485	if "--ask" in myopts:	3539	if "--ask" in myopts:
Lines 3631-3638 Link Here
3631	myopts.append(x)	3685	myopts.append(x)
3632	elif x[2:] in actions:	3686	elif x[2:] in actions:
3633	if myaction:	3687	if myaction:
3634	if myaction not in ["system", "world"]:	3688	myaction="--"+myaction
3635	myaction="--"+myaction
3636	print	3689	print
3637	print red("!!!")+green(" Multiple actions requested... Please choose one only.")	3690	print red("!!!")+green(" Multiple actions requested... Please choose one only.")
3638	print red("!!!")+" '"+darkgreen(myaction)+"' "+red("or")+" '"+darkgreen(x)+"'"	3691	print red("!!!")+" '"+darkgreen(myaction)+"' "+red("or")+" '"+darkgreen(x)+"'"
Lines 3643-3650 Link Here
3643	print "!!! Error:",x,"is an invalid option."	3696	print "!!! Error:",x,"is an invalid option."
3644	sys.exit(1)	3697	sys.exit(1)
3645	elif (not myaction) and (x in actions):	3698	elif (not myaction) and (x in actions):
3646	if x not in ["system", "world"]:	3699	print red("*** Deprecated use of action '%s', use '--%s' instead" % (x,x))
3647	print red("*** Deprecated use of action '%s', use '--%s' instead" % (x,x))
3648	if myaction:	3700	if myaction:
3649	print	3701	print
3650	print red("!!!")+green(" Multiple actions requested... Please choose one only.")	3702	print red("!!!")+green(" Multiple actions requested... Please choose one only.")
Lines 3833-3842 Link Here
3833		3885
3834	"""	3886	"""
3835		3887
3836	if (myaction in ["world", "system"]) and myfiles:
3837	print "emerge: please specify a package class (\"world\" or \"system\") or individual packages, but not both."
3838	sys.exit(1)
3839
3840	for x in myfiles:	3888	for x in myfiles:
3841	ext = os.path.splitext(x)[1]	3889	ext = os.path.splitext(x)[1]
3842	if (ext == ".ebuild" or ext == ".tbz2") and os.path.exists(os.path.abspath(x)):	3890	if (ext == ".ebuild" or ext == ".tbz2") and os.path.exists(os.path.abspath(x)):
3843	+ac592a22-f3fe-0310-977e-98394eae9e84:/main/trunk:4434	3891	+ac592a22-f3fe-0310-977e-98394eae9e84:/main/trunk:4434

Return to bug 6411

Line 0 Link Here

(-)pym/portage_sets.py (+88 lines)
		1	# portage_sets.py - Portage Sets functionality
		2	# Copyright 2006 Gentoo Foundation
		3	# Distributed under the terms of the GNU General Public License v2
		4	# $Id: $
		5
		6	import os
		7
		8	from portage_dep import isvalidatom
		9	from portage_const import SET_PATH, WORLD_FILE
		10
		11	class PackageSet(list):
		12	""" Abstract PackageSet Class
		13	Ironically this is a python list and NOT a set, as we need to preserve
		14	order here.
		15	"""
		16
		17	def __init__( self ):
		18	""" All PackageSet classes have items """
		19	self.items = None
		20
		21	def PackageSetFactory( set_name, root="/", settings=None ):
		22	""" Give me a valid set_name and I'll make you the right one.
		23	(settings,root) are require for certain types of Sets (glsa,all,system) """
		24
		25	if os.path.exists( SET_PATH + os.sep + set_name ):
		26	return PackageSetFile( SET_PATH + os.sep + set_name )
		27	elif set_name in "world":
		28	return WorldSet( root )
		29	elif not settings:
		30	raise ValueError( "Settings is require for sets: %s" % ["system","all","glsa"] )
		31	elif set_name in "system":
		32	return SystemSet( settings )
		33	elif set_name in "all":
		34	return AllSet( root, settings )
		35	elif set_name in "glsa":
		36	return GLSASet( settings )
		37	else:
		38	return PackageSetFile( set_name )
		39
		40	class AllSet(PackageSet):
		41	""" Returns a set of all installed packages (CPs) """
		42
		43	def __init__( self, root, settings ):
		44	""" Pass me a config to work with. """
		45	from portage import vartree
		46	vartree = vartree( root=root, settings=settings )
		47	self.items = vartree.dbapi.cp_all()
		48
		49	class SystemSet(PackageSet):
		50	""" Returns a set of all packages in 'system' """
		51
		52	def __init__( self, settings ):
		53	""" I need a config object to inspect. """
		54	# settings.packages all start with "*", so we strip it here.
		55	self.items = [item[1:] for item in settings.packages]
		56
		57	class PackageSetList(PackageSet):
		58	""" Represents a set of packages """
		59
		60	def __init__( self, cpvs ):
		61	""" Create a new object given a list of atoms (cps or cpvs) """
		62	self.items = cpvs
		63
		64	class WorldSet(PackageSet):
65	""" Represents everything in "world", aka installed manually by the user. """
66
67	def __init__( self, root ):
68	""" Create a new object given a root to pull from. """
69	self.items = PackageSetFile( root + WORLD_FILE ).items
70
71	class GLSASet(PackageSet):
72	""" Represents a set of packages worth upgrading for security reasons """
73
74	def __init__( self, root ):
75	raise NotImplementedError("GLSA Set is not written yet")
76
77	class PackageSetFile(PackageSet):
78	""" Represents a set of packages loaded from a file"""
79
80	def __init__( self, filename ):
81	""" Create a new object given a filename to load a set from """
82	handle = open(filename, "r")
83	items = handle.readlines()
84	items = [l for l in items if not l.startswith("#")]
85	items = [item.rstrip() for item in items]
86	items = [pkg for pkg in items if isvalidatom(pkg)]
87	self.items = items
88	self.filename = filename