qs/src/GLIPortage.py

"""
# Copyright 1999-2005 Gentoo Foundation
# This source code is distributed under the terms of version 2 of the GNU
# General Public License as published by the Free Software Foundation, a copy
# of which can be found in the main directory of this project.
Gentoo Linux Installer

$Id: GLIPortage.py,v 1.28 2006/01/03 04:09:36 agaffney Exp $
"""

import re
import os
import GLIUtility
from GLIException import GLIException

class GLIPortage(object):

        def __init__(self, chroot_dir, grp_install, logger, debug, cc, compile_logfile):
                self._chroot_dir = chroot_dir
                self._grp_install = grp_install
                self._logger = logger
                self._debug = debug
                self._cc = cc
                self._compile_logfile = compile_logfile

        def get_deps(self, pkgs):
                pkglist = []
                if isinstance(pkgs, str):
                        pkgs = pkgs.split()
                for pkg in pkgs:
                        if self._debug: self._logger.log("get_deps(): pkg is " + pkg)
                        if not self._grp_install or not self.get_best_version_vdb(pkg):
                                if self._debug: self._logger.log("get_deps(): grabbing compile deps")
                                tmppkglist = GLIUtility.spawn("emerge -p " + pkg + r" 2>/dev/null | grep -e '^\[[a-z]' | cut -d ']' -f2 | sed -e 's:^ ::' -e 's: .\+$::'", chroot=self._chroot_dir, return_output=True)[1].strip().split("\n")
                        else:
                                if self._debug: self._logger.log("get_deps(): grabbing binary deps")
                                # The runtimedeps.py script generates a package install order that is *very* different from emerge itself
#                               tmppkglist = GLIUtility.spawn("python ../../runtimedeps.py " + self._chroot_dir + " " + pkg, return_output=True)[1].strip().split("\n")
                                tmppkglist = []
                                for tmppkg in GLIUtility.spawn("emerge -p " + pkg + r" 2>/dev/null | grep -e '^\[[a-z]' | cut -d ']' -f2 | sed -e 's:^ ::' -e 's: .\+$::'", chroot=self._chroot_dir, return_output=True)[1].strip().split("\n"):
                                        if self._debug: self._logger.log("get_deps(): looking at " + tmppkg)
                                        if self.get_best_version_vdb("=" + tmppkg):
                                                if self._debug: self._logger.log("get_deps(): package " + tmppkg + " in host vdb...adding to tmppkglist")
                                                tmppkglist.append(tmppkg)
                        if self._debug: self._logger.log("get_deps(): deplist for " + pkg + ": " + str(tmppkglist))
                        for tmppkg in tmppkglist:
                                if self._debug: self._logger.log("get_deps(): checking to see if " + tmppkg + " is already in pkglist")
                                if not tmppkg in pkglist and not self.get_best_version_vdb_chroot("=" + tmppkg):
                                        if self._debug: self._logger.log("get_deps(): adding " + tmppkg + " to pkglist")
                                        pkglist.append(tmppkg)
                if self._debug: self._logger.log("get_deps(): pkglist is " + str(pkglist))
                return pkglist

        def copy_pkg_to_chroot(self, package, use_root=False):
                symlinks = { '/bin/': '/mnt/livecd/bin/', '/boot/': '/mnt/livecd/boot/', '/lib/': '/mnt/livecd/lib/', 
                             '/opt/': '/mnt/livecd/opt/', '/sbin/': '/mnt/livecd/sbin/', '/usr/': '/mnt/livecd/usr/',
                             '/etc/gconf/': '/usr/livecd/gconf/' }

                tmpdir = "/var/tmp/portage"
                image_dir = tmpdir + "/" + package.split("/")[1] + "/image"
                root_cmd = ""
                tmp_chroot_dir = self._chroot_dir
                portage_tmpdir = "/var/tmp/portage"
                if use_root:
                        root_cmd = "ROOT=" + self._chroot_dir
                        tmp_chroot_dir = ""
                        portage_tmpdir = self._chroot_dir + "/var/tmp/portage"

                # Copy the vdb entry for the package from the LiveCD to the chroot
                if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying vdb entry for " + package)
                if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir -p " + self._chroot_dir + "/var/db/pkg/" + package + " && cp -a /var/db/pkg/" + package + "/* " + self._chroot_dir + "/var/db/pkg/" + package)):
                        raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy vdb entry for " + package)

                # Create the image dir in the chroot
                if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running 'mkdir -p " + self._chroot_dir + image_dir + "'")
                if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir -p " + self._chroot_dir + image_dir)):
                        raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create image dir for " + package)

                # Create list of files for tar to work with from CONTENTS file in vdb entry
                entries = GLIUtility.parse_vdb_contents("/var/db/pkg/" + package + "/CONTENTS")
                if not entries:
                        if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping tar and symlink fixup")
                else:
                        if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot: files for " + package + ": " + str(entries))
                        try:
                                tarfiles = open("/tmp/tarfilelist", "w")
                                for entry in entries:
                                        parts = entry.split(" ")
                                        # Hack for symlink crappiness
#                                       for symlink in symlinks:
#                                               if parts[0].startswith(symlink):
#                                                       parts[0] = symlinks[symlink] + parts[0][len(symlink):]
                                        tarfiles.write(parts[0] + "\n")
                                tarfiles.close()
                        except:
                                raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create filelist for " + package)

                        # Use tar to transfer files into IMAGE directory
                        if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running 'tar -c --files-from=/tmp/tarfilelist --no-recursion 2>/dev/null | tar -C " + self._chroot_dir + image_dir + " -x'")
                        if not GLIUtility.exitsuccess(GLIUtility.spawn("tar -c --files-from=/tmp/tarfilelist --no-recursion 2>/dev/null | tar -C " + self._chroot_dir + image_dir + " -x")):
                                raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute tar for " + package)

                        # More symlink crappiness hacks
                        for symlink in symlinks:
                                if GLIUtility.is_file(self._chroot_dir + image_dir + symlinks[symlink]):
                                        if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): fixing " + symlink + " symlink ickiness stuff in " + image_dir + " for " + package)
                                        if os.path.islink(self._chroot_dir + image_dir + symlink):
                                                if not GLIUtiltiy.exitsuccess(GLIUtility.spawn("rm " + self._chroot_dir + image_dir + symlink)):
                                                        raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not remove symlink " + symlink + " for " + package)
                                        if not GLIUtility.exitsuccess(GLIUtility.spawn("mv " + self._chroot_dir + image_dir + symlinks[symlink] + " " + self._chroot_dir + image_dir + symlink)):
                                                raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not fix " + symlink + " symlink ickiness for " + package)

                # Run pkg_setup
                if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running pkg_setup for " + package)
                if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " ebuild /var/db/pkg/" + package + "/*.ebuild setup", chroot=tmp_chroot_dir)):
                        raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute pkg_setup for " + package)

                # Run pkg_preinst
                if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running preinst for " + package)
                if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " ebuild /var/db/pkg/" + package + "/*.ebuild preinst", chroot=tmp_chroot_dir)):
                        raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute preinst for " + package)

                # Copy files from image_dir to chroot
                if not entries:
                        if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping copy from image dir to /")
                else:
                        if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying files from " + image_dir + " to / for " + package)
                        if not GLIUtility.exitsuccess(GLIUtility.spawn("cp -a " + self._chroot_dir + image_dir + "/* " + self._chroot_dir)):
                                raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy files from " + image_dir + " to / for " + package)

                # Run pkg_postinst
                if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running postinst for " + package)
                if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " ebuild /var/db/pkg/" + package + "/*.ebuild postinst", chroot=tmp_chroot_dir)):
                        raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute postinst for " + package)

                # Remove image_dir
                if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): removing " + image_dir + " for " + package)
                if not GLIUtility.exitsuccess(GLIUtility.spawn("rm -rf " + self._chroot_dir + image_dir)):
                        raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not remove + " + image_dir + " for " + package)

        def add_pkg_to_world(self, package):
                if package.find("/") == -1:
                        package = self.get_best_version_vdb_chroot(package)
                if not package: return False
                expr = re.compile('^=?(.+?/.+?)(-\d.+)?$')
                res = expr.match(package)
                if res:
                        GLIUtility.spawn("echo " + res.group(1) + " >> " + self._chroot_dir + "/var/lib/portage/world")

        def get_best_version_vdb(self, package):
                return GLIUtility.spawn("portageq best_version / " + package, return_output=True)[1].strip()

        def get_best_version_vdb_chroot(self, package):
                return GLIUtility.spawn("portageq best_version / " + package, chroot=self._chroot_dir, return_output=True)[1].strip()

#       def get_best_version_tree(self, package):
#               return portage.best(tree.match(package))

        def emerge(self, packages, add_to_world=True):
                if isinstance(packages, str):
                        packages = packages.split()
                pkglist = self.get_deps(packages)
                if self._debug: self._logger.log("install_packages(): pkglist is " + str(pkglist))
                for i, pkg in enumerate(pkglist):
                        if self._debug: self._logger.log("install_packages(): processing package " + pkg)
                        self._cc.addNotification("progress", (float(i) / len(pkglist), "Emerging " + pkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")"))
                        if not self._grp_install or not self.get_best_version_vdb("=" + pkg):
                                status = GLIUtility.spawn("emerge -1 =" + pkg, display_on_tty8=True, chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)
#                               status = self._emerge("=" + pkg)
                                if not GLIUtility.exitsuccess(status):
                                        raise GLIException("EmergePackageError", "fatal", "emerge", "Could not emerge " + pkg + "!")
                        else:
#                               try:
                                self.copy_pkg_to_chroot(pkg)
#                               except:
#                                       raise GLIException("EmergePackageError", "fatal", "emerge", "Could not emerge " + pkg + "!")
                        self._cc.addNotification("progress", (float(i+1) / len(pkglist), "Done emerging " + pkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")"))
                if add_to_world:
                        for package in packages:
                                self.add_pkg_to_world(package)
1	agaffney	1181	"""
2			# Copyright 1999-2005 Gentoo Foundation
3			# This source code is distributed under the terms of version 2 of the GNU
4			# General Public License as published by the Free Software Foundation, a copy
5			# of which can be found in the main directory of this project.
6			Gentoo Linux Installer
7
8	agaffney	1216	$Id: GLIPortage.py,v 1.28 2006/01/03 04:09:36 agaffney Exp $
9	agaffney	1181	"""
10
11	agaffney	1182	import re
12	agaffney	1216	import os
13	agaffney	1181	import GLIUtility
14	agaffney	1204	from GLIException import GLIException
15	agaffney	1181
16			class GLIPortage(object):
17
18	agaffney	1205	def __init__(self, chroot_dir, grp_install, logger, debug, cc, compile_logfile):
19	agaffney	1182	self._chroot_dir = chroot_dir
20	agaffney	1189	self._grp_install = grp_install
21	agaffney	1182	self._logger = logger
22			self._debug = debug
23	agaffney	1205	self._cc = cc
24			self._compile_logfile = compile_logfile
25	agaffney	1181
26	agaffney	1183	def get_deps(self, pkgs):
27	agaffney	1189	pkglist = []
28			if isinstance(pkgs, str):
29			pkgs = pkgs.split()
30			for pkg in pkgs:
31	agaffney	1190	if self._debug: self._logger.log("get_deps(): pkg is " + pkg)
32	agaffney	1189	if not self._grp_install or not self.get_best_version_vdb(pkg):
33	agaffney	1190	if self._debug: self._logger.log("get_deps(): grabbing compile deps")
34	agaffney	1208	tmppkglist = GLIUtility.spawn("emerge -p " + pkg + r" 2>/dev/null \| grep -e '^\[[a-z]' \| cut -d ']' -f2 \| sed -e 's:^ ::' -e 's: .\+$::'", chroot=self._chroot_dir, return_output=True)[1].strip().split("\n")
35	agaffney	1189	else:
36	agaffney	1190	if self._debug: self._logger.log("get_deps(): grabbing binary deps")
37	agaffney	1210	# The runtimedeps.py script generates a package install order that is very different from emerge itself
38			# tmppkglist = GLIUtility.spawn("python ../../runtimedeps.py " + self._chroot_dir + " " + pkg, return_output=True)[1].strip().split("\n")
39			tmppkglist = []
40	agaffney	1214	for tmppkg in GLIUtility.spawn("emerge -p " + pkg + r" 2>/dev/null \| grep -e '^\[[a-z]' \| cut -d ']' -f2 \| sed -e 's:^ ::' -e 's: .\+$::'", chroot=self._chroot_dir, return_output=True)[1].strip().split("\n"):
41	agaffney	1210	if self._debug: self._logger.log("get_deps(): looking at " + tmppkg)
42	agaffney	1211	if self.get_best_version_vdb("=" + tmppkg):
43	agaffney	1210	if self._debug: self._logger.log("get_deps(): package " + tmppkg + " in host vdb...adding to tmppkglist")
44			tmppkglist.append(tmppkg)
45	agaffney	1190	if self._debug: self._logger.log("get_deps(): deplist for " + pkg + ": " + str(tmppkglist))
46	agaffney	1189	for tmppkg in tmppkglist:
47	agaffney	1192	if self._debug: self._logger.log("get_deps(): checking to see if " + tmppkg + " is already in pkglist")
48	agaffney	1194	if not tmppkg in pkglist and not self.get_best_version_vdb_chroot("=" + tmppkg):
49	agaffney	1192	if self._debug: self._logger.log("get_deps(): adding " + tmppkg + " to pkglist")
50	agaffney	1189	pkglist.append(tmppkg)
51	agaffney	1190	if self._debug: self._logger.log("get_deps(): pkglist is " + str(pkglist))
52	agaffney	1189	return pkglist
53	agaffney	1182
54	agaffney	1199	def copy_pkg_to_chroot(self, package, use_root=False):
55	agaffney	1182	symlinks = { '/bin/': '/mnt/livecd/bin/', '/boot/': '/mnt/livecd/boot/', '/lib/': '/mnt/livecd/lib/',
56			'/opt/': '/mnt/livecd/opt/', '/sbin/': '/mnt/livecd/sbin/', '/usr/': '/mnt/livecd/usr/',
57			'/etc/gconf/': '/usr/livecd/gconf/' }
58
59	agaffney	1208	tmpdir = "/var/tmp/portage"
60			image_dir = tmpdir + "/" + package.split("/")[1] + "/image"
61	agaffney	1198	root_cmd = ""
62			tmp_chroot_dir = self._chroot_dir
63	agaffney	1204	portage_tmpdir = "/var/tmp/portage"
64	agaffney	1198	if use_root:
65			root_cmd = "ROOT=" + self._chroot_dir
66	agaffney	1203	tmp_chroot_dir = ""
67	agaffney	1204	portage_tmpdir = self._chroot_dir + "/var/tmp/portage"
68	agaffney	1198
69	agaffney	1182	# Copy the vdb entry for the package from the LiveCD to the chroot
70			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying vdb entry for " + package)
71			if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir -p " + self._chroot_dir + "/var/db/pkg/" + package + " && cp -a /var/db/pkg/" + package + "/* " + self._chroot_dir + "/var/db/pkg/" + package)):
72			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy vdb entry for " + package)
73
74	agaffney	1208	# Create the image dir in the chroot
75			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running 'mkdir -p " + self._chroot_dir + image_dir + "'")
76			if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir -p " + self._chroot_dir + image_dir)):
77			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create image dir for " + package)
78
79	agaffney	1182	# Create list of files for tar to work with from CONTENTS file in vdb entry
80			entries = GLIUtility.parse_vdb_contents("/var/db/pkg/" + package + "/CONTENTS")
81	agaffney	1208	if not entries:
82			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping tar and symlink fixup")
83			else:
84			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot: files for " + package + ": " + str(entries))
85			try:
86			tarfiles = open("/tmp/tarfilelist", "w")
87			for entry in entries:
88			parts = entry.split(" ")
89			# Hack for symlink crappiness
90	agaffney	1216	# for symlink in symlinks:
91			# if parts[0].startswith(symlink):
92			# parts[0] = symlinks[symlink] + parts[0][len(symlink):]
93	agaffney	1208	tarfiles.write(parts[0] + "\n")
94			tarfiles.close()
95			except:
96			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create filelist for " + package)
97	agaffney	1182
98	agaffney	1208	# Use tar to transfer files into IMAGE directory
99			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running 'tar -c --files-from=/tmp/tarfilelist --no-recursion 2>/dev/null \| tar -C " + self._chroot_dir + image_dir + " -x'")
100			if not GLIUtility.exitsuccess(GLIUtility.spawn("tar -c --files-from=/tmp/tarfilelist --no-recursion 2>/dev/null \| tar -C " + self._chroot_dir + image_dir + " -x")):
101			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute tar for " + package)
102	agaffney	1182
103	agaffney	1208	# More symlink crappiness hacks
104			for symlink in symlinks:
105			if GLIUtility.is_file(self._chroot_dir + image_dir + symlinks[symlink]):
106			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): fixing " + symlink + " symlink ickiness stuff in " + image_dir + " for " + package)
107	agaffney	1216	if os.path.islink(self._chroot_dir + image_dir + symlink):
108			if not GLIUtiltiy.exitsuccess(GLIUtility.spawn("rm " + self._chroot_dir + image_dir + symlink)):
109			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not remove symlink " + symlink + " for " + package)
110	agaffney	1208	if not GLIUtility.exitsuccess(GLIUtility.spawn("mv " + self._chroot_dir + image_dir + symlinks[symlink] + " " + self._chroot_dir + image_dir + symlink)):
111	agaffney	1216	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not fix " + symlink + " symlink ickiness for " + package)
112	agaffney	1182
113			# Run pkg_setup
114			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running pkg_setup for " + package)
115	agaffney	1204	if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " ebuild /var/db/pkg/" + package + "/*.ebuild setup", chroot=tmp_chroot_dir)):
116	agaffney	1182	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute pkg_setup for " + package)
117
118			# Run pkg_preinst
119			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running preinst for " + package)
120	agaffney	1204	if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " ebuild /var/db/pkg/" + package + "/*.ebuild preinst", chroot=tmp_chroot_dir)):
121	agaffney	1182	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute preinst for " + package)
122
123			# Copy files from image_dir to chroot
124	agaffney	1208	if not entries:
125	agaffney	1209	if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping copy from image dir to /")
126	agaffney	1208	else:
127			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying files from " + image_dir + " to / for " + package)
128			if not GLIUtility.exitsuccess(GLIUtility.spawn("cp -a " + self._chroot_dir + image_dir + "/* " + self._chroot_dir)):
129			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy files from " + image_dir + " to / for " + package)
130	agaffney	1182
131			# Run pkg_postinst
132			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running postinst for " + package)
133	agaffney	1204	if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " ebuild /var/db/pkg/" + package + "/*.ebuild postinst", chroot=tmp_chroot_dir)):
134	agaffney	1182	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute postinst for " + package)
135
136			# Remove image_dir
137	agaffney	1208	if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): removing " + image_dir + " for " + package)
138	agaffney	1182	if not GLIUtility.exitsuccess(GLIUtility.spawn("rm -rf " + self._chroot_dir + image_dir)):
139			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not remove + " + image_dir + " for " + package)
140
141			def add_pkg_to_world(self, package):
142			if package.find("/") == -1:
143	agaffney	1195	package = self.get_best_version_vdb_chroot(package)
144	agaffney	1182	if not package: return False
145	agaffney	1205	expr = re.compile('^=?(.+?/.+?)(-\d.+)?$')
146	agaffney	1182	res = expr.match(package)
147			if res:
148			GLIUtility.spawn("echo " + res.group(1) + " >> " + self._chroot_dir + "/var/lib/portage/world")
149
150	agaffney	1185	def get_best_version_vdb(self, package):
151			return GLIUtility.spawn("portageq best_version / " + package, return_output=True)[1].strip()
152	agaffney	1189
153	agaffney	1194	def get_best_version_vdb_chroot(self, package):
154	agaffney	1195	return GLIUtility.spawn("portageq best_version / " + package, chroot=self._chroot_dir, return_output=True)[1].strip()
155	agaffney	1194
156	agaffney	1184	# def get_best_version_tree(self, package):
157			# return portage.best(tree.match(package))
158	agaffney	1205
159			def emerge(self, packages, add_to_world=True):
160			if isinstance(packages, str):
161			packages = packages.split()
162			pkglist = self.get_deps(packages)
163			if self._debug: self._logger.log("install_packages(): pkglist is " + str(pkglist))
164			for i, pkg in enumerate(pkglist):
165			if self._debug: self._logger.log("install_packages(): processing package " + pkg)
166	agaffney	1208	self._cc.addNotification("progress", (float(i) / len(pkglist), "Emerging " + pkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")"))
167			if not self._grp_install or not self.get_best_version_vdb("=" + pkg):
168	agaffney	1205	status = GLIUtility.spawn("emerge -1 =" + pkg, display_on_tty8=True, chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)
169			# status = self._emerge("=" + pkg)
170			if not GLIUtility.exitsuccess(status):
171			raise GLIException("EmergePackageError", "fatal", "emerge", "Could not emerge " + pkg + "!")
172			else:
173			# try:
174			self.copy_pkg_to_chroot(pkg)
175			# except:
176			# raise GLIException("EmergePackageError", "fatal", "emerge", "Could not emerge " + pkg + "!")
177	agaffney	1208	self._cc.addNotification("progress", (float(i+1) / len(pkglist), "Done emerging " + pkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")"))
178	agaffney	1205	if add_to_world:
179			for package in packages:
180			self.add_pkg_to_world(package)