Bug #275047 - Split _emerge/__init__.py into smaller pieces. Thanks to

Sebastian Mingramm (few) <s.mingramm@gmx.de> for this patch.

svn path=/main/trunk/; revision=13663

1 files changed, 271 insertions, 0 deletions

diff --git a/pym/_emerge/EbuildBuild.py b/pym/_emerge/EbuildBuild.py
new file mode 100644
index 000000000..d633519c9
--- /dev/null
+++ b/pym/_emerge/EbuildBuild.py
@@ -0,0 +1,271 @@
+from _emerge.EbuildExecuter import EbuildExecuter
+from _emerge.EbuildPhase import EbuildPhase
+from _emerge.EbuildBinpkg import EbuildBinpkg
+from _emerge.EbuildFetcher import EbuildFetcher
+from _emerge.CompositeTask import CompositeTask
+from _emerge.EbuildMerge import EbuildMerge
+from _emerge.EbuildFetchonly import EbuildFetchonly
+from _emerge.EbuildBuildDir import EbuildBuildDir
+from portage.util import writemsg
+try:
+	import portage
+except ImportError:
+	from os import path as osp
+	import sys
+	sys.path.insert(0, osp.join(osp.dirname(osp.dirname(osp.realpath(__file__))), "pym"))
+	import portage
+import os
+from portage.output import colorize
+class EbuildBuild(CompositeTask):
+
+	__slots__ = ("args_set", "config_pool", "find_blockers",
+		"ldpath_mtimes", "logger", "opts", "pkg", "pkg_count",
+		"prefetcher", "settings", "world_atom") + \
+		("_build_dir", "_buildpkg", "_ebuild_path", "_issyspkg", "_tree")
+
+	def _start(self):
+
+		logger = self.logger
+		opts = self.opts
+		pkg = self.pkg
+		settings = self.settings
+		world_atom = self.world_atom
+		root_config = pkg.root_config
+		tree = "porttree"
+		self._tree = tree
+		portdb = root_config.trees[tree].dbapi
+		settings.setcpv(pkg)
+		settings.configdict["pkg"]["EMERGE_FROM"] = pkg.type_name
+		ebuild_path = portdb.findname(self.pkg.cpv)
+		self._ebuild_path = ebuild_path
+
+		prefetcher = self.prefetcher
+		if prefetcher is None:
+			pass
+		elif not prefetcher.isAlive():
+			prefetcher.cancel()
+		elif prefetcher.poll() is None:
+
+			waiting_msg = "Fetching files " + \
+				"in the background. " + \
+				"To view fetch progress, run `tail -f " + \
+				"/var/log/emerge-fetch.log` in another " + \
+				"terminal."
+			msg_prefix = colorize("GOOD", " * ")
+			from textwrap import wrap
+			waiting_msg = "".join("%s%s\n" % (msg_prefix, line) \
+				for line in wrap(waiting_msg, 65))
+			if not self.background:
+				writemsg(waiting_msg, noiselevel=-1)
+
+			self._current_task = prefetcher
+			prefetcher.addExitListener(self._prefetch_exit)
+			return
+
+		self._prefetch_exit(prefetcher)
+
+	def _prefetch_exit(self, prefetcher):
+
+		opts = self.opts
+		pkg = self.pkg
+		settings = self.settings
+
+		if opts.fetchonly:
+				fetcher = EbuildFetchonly(
+					fetch_all=opts.fetch_all_uri,
+					pkg=pkg, pretend=opts.pretend,
+					settings=settings)
+				retval = fetcher.execute()
+				self.returncode = retval
+				self.wait()
+				return
+
+		fetcher = EbuildFetcher(config_pool=self.config_pool,
+			fetchall=opts.fetch_all_uri,
+			fetchonly=opts.fetchonly,
+			background=self.background,
+			pkg=pkg, scheduler=self.scheduler)
+
+		self._start_task(fetcher, self._fetch_exit)
+
+	def _fetch_exit(self, fetcher):
+		opts = self.opts
+		pkg = self.pkg
+
+		fetch_failed = False
+		if opts.fetchonly:
+			fetch_failed = self._final_exit(fetcher) != os.EX_OK
+		else:
+			fetch_failed = self._default_exit(fetcher) != os.EX_OK
+
+		if fetch_failed and fetcher.logfile is not None and \
+			os.path.exists(fetcher.logfile):
+			self.settings["PORTAGE_LOG_FILE"] = fetcher.logfile
+
+		if not fetch_failed and fetcher.logfile is not None:
+			# Fetch was successful, so remove the fetch log.
+			try:
+				os.unlink(fetcher.logfile)
+			except OSError:
+				pass
+
+		if fetch_failed or opts.fetchonly:
+			self.wait()
+			return
+
+		logger = self.logger
+		opts = self.opts
+		pkg_count = self.pkg_count
+		scheduler = self.scheduler
+		settings = self.settings
+		features = settings.features
+		ebuild_path = self._ebuild_path
+		system_set = pkg.root_config.sets["system"]
+
+		self._build_dir = EbuildBuildDir(pkg=pkg, settings=settings)
+		self._build_dir.lock()
+
+		# Cleaning is triggered before the setup
+		# phase, in portage.doebuild().
+		msg = " === (%s of %s) Cleaning (%s::%s)" % \
+			(pkg_count.curval, pkg_count.maxval, pkg.cpv, ebuild_path)
+		short_msg = "emerge: (%s of %s) %s Clean" % \
+			(pkg_count.curval, pkg_count.maxval, pkg.cpv)
+		logger.log(msg, short_msg=short_msg)
+
+		#buildsyspkg: Check if we need to _force_ binary package creation
+		self._issyspkg = "buildsyspkg" in features and \
+				system_set.findAtomForPackage(pkg) and \
+				not opts.buildpkg
+
+		if opts.buildpkg or self._issyspkg:
+
+			self._buildpkg = True
+
+			msg = " === (%s of %s) Compiling/Packaging (%s::%s)" % \
+				(pkg_count.curval, pkg_count.maxval, pkg.cpv, ebuild_path)
+			short_msg = "emerge: (%s of %s) %s Compile" % \
+				(pkg_count.curval, pkg_count.maxval, pkg.cpv)
+			logger.log(msg, short_msg=short_msg)
+
+		else:
+			msg = " === (%s of %s) Compiling/Merging (%s::%s)" % \
+				(pkg_count.curval, pkg_count.maxval, pkg.cpv, ebuild_path)
+			short_msg = "emerge: (%s of %s) %s Compile" % \
+				(pkg_count.curval, pkg_count.maxval, pkg.cpv)
+			logger.log(msg, short_msg=short_msg)
+
+		build = EbuildExecuter(background=self.background, pkg=pkg,
+			scheduler=scheduler, settings=settings)
+		self._start_task(build, self._build_exit)
+
+	def _unlock_builddir(self):
+		portage.elog.elog_process(self.pkg.cpv, self.settings)
+		self._build_dir.unlock()
+
+	def _build_exit(self, build):
+		if self._default_exit(build) != os.EX_OK:
+			self._unlock_builddir()
+			self.wait()
+			return
+
+		opts = self.opts
+		buildpkg = self._buildpkg
+
+		if not buildpkg:
+			self._final_exit(build)
+			self.wait()
+			return
+
+		if self._issyspkg:
+			msg = ">>> This is a system package, " + \
+				"let's pack a rescue tarball.\n"
+
+			log_path = self.settings.get("PORTAGE_LOG_FILE")
+			if log_path is not None:
+				log_file = open(log_path, 'a')
+				try:
+					log_file.write(msg)
+				finally:
+					log_file.close()
+
+			if not self.background:
+				portage.writemsg_stdout(msg, noiselevel=-1)
+
+		packager = EbuildBinpkg(background=self.background, pkg=self.pkg,
+			scheduler=self.scheduler, settings=self.settings)
+
+		self._start_task(packager, self._buildpkg_exit)
+
+	def _buildpkg_exit(self, packager):
+		"""
+		Released build dir lock when there is a failure or
+		when in buildpkgonly mode. Otherwise, the lock will
+		be released when merge() is called.
+		"""
+
+		if self._default_exit(packager) != os.EX_OK:
+			self._unlock_builddir()
+			self.wait()
+			return
+
+		if self.opts.buildpkgonly:
+			# Need to call "clean" phase for buildpkgonly mode
+			portage.elog.elog_process(self.pkg.cpv, self.settings)
+			phase = "clean"
+			clean_phase = EbuildPhase(background=self.background,
+				pkg=self.pkg, phase=phase,
+				scheduler=self.scheduler, settings=self.settings,
+				tree=self._tree)
+			self._start_task(clean_phase, self._clean_exit)
+			return
+
+		# Continue holding the builddir lock until
+		# after the package has been installed.
+		self._current_task = None
+		self.returncode = packager.returncode
+		self.wait()
+
+	def _clean_exit(self, clean_phase):
+		if self._final_exit(clean_phase) != os.EX_OK or \
+			self.opts.buildpkgonly:
+			self._unlock_builddir()
+		self.wait()
+
+	def install(self):
+		"""
+		Install the package and then clean up and release locks.
+		Only call this after the build has completed successfully
+		and neither fetchonly nor buildpkgonly mode are enabled.
+		"""
+
+		find_blockers = self.find_blockers
+		ldpath_mtimes = self.ldpath_mtimes
+		logger = self.logger
+		pkg = self.pkg
+		pkg_count = self.pkg_count
+		settings = self.settings
+		world_atom = self.world_atom
+		ebuild_path = self._ebuild_path
+		tree = self._tree
+
+		merge = EbuildMerge(find_blockers=self.find_blockers,
+			ldpath_mtimes=ldpath_mtimes, logger=logger, pkg=pkg,
+			pkg_count=pkg_count, pkg_path=ebuild_path,
+			scheduler=self.scheduler,
+			settings=settings, tree=tree, world_atom=world_atom)
+
+		msg = " === (%s of %s) Merging (%s::%s)" % \
+			(pkg_count.curval, pkg_count.maxval,
+			pkg.cpv, ebuild_path)
+		short_msg = "emerge: (%s of %s) %s Merge" % \
+			(pkg_count.curval, pkg_count.maxval, pkg.cpv)
+		logger.log(msg, short_msg=short_msg)
+
+		try:
+			rval = merge.execute()
+		finally:
+			self._unlock_builddir()
+
+		return rval
+