Attachment #195594 for bug #275217




from _emerge.create_depgraph_params import create_depgraph_params
from _emerge.create_world_atom import create_world_atom
from _emerge.DepPriority import DepPriority
from _emerge.depgraph import depgraph
from _emerge.EbuildFetcher import EbuildFetcher
from _emerge.EbuildPhase import EbuildPhase
from _emerge.emergelog import emergelog, _emerge_log_dir

from _emerge.SequentialTaskQueue import SequentialTaskQueue
from _emerge.show_invalid_depstring_notice import show_invalid_depstring_notice

import portage.proxy.lazyimport
import portage.proxy as proxy
proxy.lazyimport.lazyimport(globals(),
	'_emerge.depgraph:depgraph',
)

class Scheduler(PollScheduler):

	_opts_ignore_blockers = \




from _emerge.UnmergeDepPriority import UnmergeDepPriority
from _emerge.visible import visible

import portage.proxy.lazyimport
import portage.proxy as proxy
proxy.lazyimport.lazyimport(globals(),
	'_emerge.Scheduler:Scheduler',
)
#from _emerge.Scheduler import Scheduler
class depgraph(object):

	pkg_tree_map = RootConfig.pkg_tree_map

			self.edebug = 1
		self.spinner = spinner
		self._running_root = trees["/"]["root_config"]
		self._opts_no_restart = frozenset(["--buildpkgonly",
			"--fetchonly", "--fetch-all-uri", "--pretend"])
		self.pkgsettings = {}
		# Maps slot atom to package for each Package added to the graph.
		self._slot_pkg_map = {}

			self._pkg_cache[pkg] = pkg
		return pkg

	def _validate_blockers(self):
		"""Remove any blockers from the digraph that do not match any of the
		packages within the graph.  If necessary, create hard deps to ensure
		correct merge order such that mutually blocking packages are never

		if not self._complete_graph():
			raise self._unknown_internal_error()

		if not self._validate_blockers():
			raise self._unknown_internal_error()

		if self._slot_collision_info:

					if "--changelog" in self.myopts:
						inst_matches = vardb.match(pkg.slot_atom)
						if inst_matches:
							changelogs.extend(self._calc_changelog(
								portdb.findname(pkg_key),
								inst_matches[0], pkg_key))
				else:

			show_mask_docs()
			print

	def _calc_changelog(self,ebuildpath,current,next):
		if ebuildpath == None or not os.path.exists(ebuildpath):
			return []
		current = '-'.join(portage.catpkgsplit(current)[1:])

			return []
		return divisions

	def _find_changelog_tags(self,changelog):
		divs = []
		release = None
		while 1:

		if world_locked:
			world_set.unlock()

	def _loadResumeCommand(self, resume_data, skip_masked=True,
		skip_missing=True):
		"""
		Add a resume command to the graph and validate it in the process.  This

		mydepgraph = depgraph(settings, trees,
			myopts, myparams, spinner)
		try:
			success = mydepgraph._loadResumeCommand(mtimedb["resume"],
				skip_masked=skip_masked)
		except depgraph.UnsatisfiedResumeDep, e:
			if not skip_unsatisfied:

Return to bug 275217

Lines 27-32 Link Here

(-)pym/_emerge/Scheduler.py (-6 / +1 lines)
27	from _emerge.create_depgraph_params import create_depgraph_params	27	from _emerge.create_depgraph_params import create_depgraph_params
28	from _emerge.create_world_atom import create_world_atom	28	from _emerge.create_world_atom import create_world_atom
29	from _emerge.DepPriority import DepPriority	29	from _emerge.DepPriority import DepPriority
		30	from _emerge.depgraph import depgraph
30	from _emerge.EbuildFetcher import EbuildFetcher	31	from _emerge.EbuildFetcher import EbuildFetcher
31	from _emerge.EbuildPhase import EbuildPhase	32	from _emerge.EbuildPhase import EbuildPhase
32	from _emerge.emergelog import emergelog, _emerge_log_dir	33	from _emerge.emergelog import emergelog, _emerge_log_dir
Lines 42-53 Link Here
42	from _emerge.SequentialTaskQueue import SequentialTaskQueue	43	from _emerge.SequentialTaskQueue import SequentialTaskQueue
43	from _emerge.show_invalid_depstring_notice import show_invalid_depstring_notice	44	from _emerge.show_invalid_depstring_notice import show_invalid_depstring_notice
44		45
45	import portage.proxy.lazyimport
46	import portage.proxy as proxy
47	proxy.lazyimport.lazyimport(globals(),
48	'_emerge.depgraph:depgraph',
49	)
50
51	class Scheduler(PollScheduler):	46	class Scheduler(PollScheduler):
52		47
53	_opts_ignore_blockers = \	48	_opts_ignore_blockers = \

Lines 47-58 Link Here

(-)pym/_emerge/depgraph.py (-14 / +9 lines)
47	from _emerge.UnmergeDepPriority import UnmergeDepPriority	47	from _emerge.UnmergeDepPriority import UnmergeDepPriority
48	from _emerge.visible import visible	48	from _emerge.visible import visible
49		49
50	import portage.proxy.lazyimport
51	import portage.proxy as proxy
52	proxy.lazyimport.lazyimport(globals(),
53	'_emerge.Scheduler:Scheduler',
54	)
55	#from _emerge.Scheduler import Scheduler
56	class depgraph(object):	50	class depgraph(object):
57		51
58	pkg_tree_map = RootConfig.pkg_tree_map	52	pkg_tree_map = RootConfig.pkg_tree_map
Lines 69-75 Link Here
69	self.edebug = 1	63	self.edebug = 1
70	self.spinner = spinner	64	self.spinner = spinner
71	self._running_root = trees["/"]["root_config"]	65	self._running_root = trees["/"]["root_config"]
72	self._opts_no_restart = Scheduler._opts_no_restart	66	self._opts_no_restart = frozenset(["--buildpkgonly",
		67	"--fetchonly", "--fetch-all-uri", "--pretend"])
73	self.pkgsettings = {}	68	self.pkgsettings = {}
74	# Maps slot atom to package for each Package added to the graph.	69	# Maps slot atom to package for each Package added to the graph.
75	self._slot_pkg_map = {}	70	self._slot_pkg_map = {}
Lines 2235-2241 Link Here
2235	self._pkg_cache[pkg] = pkg	2230	self._pkg_cache[pkg] = pkg
2236	return pkg	2231	return pkg
2237		2232
2238	def validate_blockers(self):	2233	def _validate_blockers(self):
2239	"""Remove any blockers from the digraph that do not match any of the	2234	"""Remove any blockers from the digraph that do not match any of the
2240	packages within the graph. If necessary, create hard deps to ensure	2235	packages within the graph. If necessary, create hard deps to ensure
2241	correct merge order such that mutually blocking packages are never	2236	correct merge order such that mutually blocking packages are never
Lines 2625-2631 Link Here
2625	if not self._complete_graph():	2620	if not self._complete_graph():
2626	raise self._unknown_internal_error()	2621	raise self._unknown_internal_error()
2627		2622
2628	if not self.validate_blockers():	2623	if not self._validate_blockers():
2629	raise self._unknown_internal_error()	2624	raise self._unknown_internal_error()
2630		2625
2631	if self._slot_collision_info:	2626	if self._slot_collision_info:
Lines 3772-3778 Link Here
3772	if "--changelog" in self.myopts:	3767	if "--changelog" in self.myopts:
3773	inst_matches = vardb.match(pkg.slot_atom)	3768	inst_matches = vardb.match(pkg.slot_atom)
3774	if inst_matches:	3769	if inst_matches:
3775	changelogs.extend(self.calc_changelog(	3770	changelogs.extend(self._calc_changelog(
3776	portdb.findname(pkg_key),	3771	portdb.findname(pkg_key),
3777	inst_matches[0], pkg_key))	3772	inst_matches[0], pkg_key))
3778	else:	3773	else:
Lines 4267-4273 Link Here
4267	show_mask_docs()	4262	show_mask_docs()
4268	print	4263	print
4269		4264
4270	def calc_changelog(self,ebuildpath,current,next):	4265	def _calc_changelog(self,ebuildpath,current,next):
4271	if ebuildpath == None or not os.path.exists(ebuildpath):	4266	if ebuildpath == None or not os.path.exists(ebuildpath):
4272	return []	4267	return []
4273	current = '-'.join(portage.catpkgsplit(current)[1:])	4268	current = '-'.join(portage.catpkgsplit(current)[1:])
Lines 4301-4307 Link Here
4301	return []	4296	return []
4302	return divisions	4297	return divisions
4303		4298
4304	def find_changelog_tags(self,changelog):	4299	def _find_changelog_tags(self,changelog):
4305	divs = []	4300	divs = []
4306	release = None	4301	release = None
4307	while 1:	4302	while 1:
Lines 4376-4382 Link Here
4376	if world_locked:	4371	if world_locked:
4377	world_set.unlock()	4372	world_set.unlock()
4378		4373
4379	def loadResumeCommand(self, resume_data, skip_masked=True,	4374	def _loadResumeCommand(self, resume_data, skip_masked=True,
4380	skip_missing=True):	4375	skip_missing=True):
4381	"""	4376	"""
4382	Add a resume command to the graph and validate it in the process. This	4377	Add a resume command to the graph and validate it in the process. This
Lines 4802-4808 Link Here
4802	mydepgraph = depgraph(settings, trees,	4797	mydepgraph = depgraph(settings, trees,
4803	myopts, myparams, spinner)	4798	myopts, myparams, spinner)
4804	try:	4799	try:
4805	success = mydepgraph.loadResumeCommand(mtimedb["resume"],	4800	success = mydepgraph._loadResumeCommand(mtimedb["resume"],
4806	skip_masked=skip_masked)	4801	skip_masked=skip_masked)
4807	except depgraph.UnsatisfiedResumeDep, e:	4802	except depgraph.UnsatisfiedResumeDep, e:
4808	if not skip_unsatisfied:	4803	if not skip_unsatisfied: