trunk/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.42 2006/02/17 17:47:40 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 not pkg: continue
                        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 parse_vdb_contents(self, file):
                entries = []
                try:
                        vdbfile = open(file, "r")
                except:
                        return entries
                for line in vdbfile.readlines():
                        parts = line.strip().split(" ")
                        if parts[0] == "obj":
                                entries.append(parts[1])
#                       elif parts[0] == "dir":
#                               entries.append(parts[1] + "/")
                        elif parts[0] == "sym":
                                entries.append(" ".join(parts[1:4]))
                entries.sort()
                return entries

        def copy_pkg_to_chroot(self, package, use_root=False, ignore_missing=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"
                vdb_dir = "/var/db/pkg/"
                if use_root:
                        root_cmd = "ROOT=" + self._chroot_dir
                        tmp_chroot_dir = ""
                        portage_tmpdir = self._chroot_dir + "/var/tmp/portage"
                        vdb_dir = self._chroot_dir + "/var/db/pkg/"

                # Check to see if package is actually in vdb
                if not GLIUtility.is_file("/var/db/pkg/" + package):
                        if ignore_missing:
                                if self._debug:
                                        self._logger.log("DEBUG: copy_pkg_to_chroot(): package " + package + " does not have a vdb entry but ignore_missing=True...ignoring error")
                                return
                        else:
                                raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "There is no vdb entry for " + package)

                # 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 = self.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 -cp --files-from=/tmp/tarfilelist --no-recursion 2>/dev/null | tar -C " + self._chroot_dir + image_dir + " -xp'")
                        if not GLIUtility.exitsuccess(GLIUtility.spawn("tar -cp --files-from=/tmp/tarfilelist --no-recursion 2>/dev/null | tar -C " + self._chroot_dir + image_dir + " -xp")):
                                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 os.path.islink(self._chroot_dir + image_dir + symlink):
#                                       if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): fixing " + symlink + " symlink ickiness stuff in " + image_dir + " for " + package)
#                                       GLIUtility.spawn("rm " + self._chroot_dir + image_dir + symlink)
#                                       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 " + vdb_dir + 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 " + vdb_dir + 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)):
                        if not GLIUtility.exitsuccess(GLIUtility.spawn("tar -C " + self._chroot_dir + image_dir + "/ -c . | tar -C " + self._chroot_dir + "/ -x")):
                                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 " + vdb_dir + 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)

                # Run env-update
                if not use_root:
                        if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running env-update inside chroot")
                        if not GLIUtility.exitsuccess(GLIUtility.spawn("env-update", chroot=self._chroot_dir)):
                                raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not run env-update 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):
                if package.startswith('='):
                        package = package[1:]
                        if GLIUtility.is_file("/var/db/pkg/" + package):
                                return package
                        else:
                                return ""
                else:
                        return GLIUtility.spawn("portageq best_version / " + package, return_output=True)[1].strip()

        def get_best_version_vdb_chroot(self, package):
                if package.startswith('='):
                        package = package[1:]
                        if GLIUtility.is_file(self._chroot_dir + "/var/db/pkg/" + package):
                                return package
                        else:
                                return ""
                else:
                        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()
                self._cc.addNotification("progress", (0, "Calculating dependencies for " + " ".join(packages)))
                pkglist = self.get_deps(packages)
                if self._debug: self._logger.log("install_packages(): pkglist is " + str(pkglist))
                for i, pkg in enumerate(pkglist):
                        if not pkg: continue
                        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	1305	$Id: GLIPortage.py,v 1.42 2006/02/17 17:47:40 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	1305	if not pkg: continue
32	agaffney	1190	if self._debug: self._logger.log("get_deps(): pkg is " + pkg)
33	agaffney	1189	if not self._grp_install or not self.get_best_version_vdb(pkg):
34	agaffney	1190	if self._debug: self._logger.log("get_deps(): grabbing compile deps")
35	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")
36	agaffney	1189	else:
37	agaffney	1190	if self._debug: self._logger.log("get_deps(): grabbing binary deps")
38	agaffney	1210	# The runtimedeps.py script generates a package install order that is very different from emerge itself
39			# tmppkglist = GLIUtility.spawn("python ../../runtimedeps.py " + self._chroot_dir + " " + pkg, return_output=True)[1].strip().split("\n")
40			tmppkglist = []
41	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"):
42	agaffney	1210	if self._debug: self._logger.log("get_deps(): looking at " + tmppkg)
43	agaffney	1211	if self.get_best_version_vdb("=" + tmppkg):
44	agaffney	1210	if self._debug: self._logger.log("get_deps(): package " + tmppkg + " in host vdb...adding to tmppkglist")
45			tmppkglist.append(tmppkg)
46	agaffney	1190	if self._debug: self._logger.log("get_deps(): deplist for " + pkg + ": " + str(tmppkglist))
47	agaffney	1189	for tmppkg in tmppkglist:
48	agaffney	1192	if self._debug: self._logger.log("get_deps(): checking to see if " + tmppkg + " is already in pkglist")
49	agaffney	1194	if not tmppkg in pkglist and not self.get_best_version_vdb_chroot("=" + tmppkg):
50	agaffney	1192	if self._debug: self._logger.log("get_deps(): adding " + tmppkg + " to pkglist")
51	agaffney	1189	pkglist.append(tmppkg)
52	agaffney	1190	if self._debug: self._logger.log("get_deps(): pkglist is " + str(pkglist))
53	agaffney	1189	return pkglist
54	agaffney	1182
55	agaffney	1221	def parse_vdb_contents(self, file):
56			entries = []
57			try:
58			vdbfile = open(file, "r")
59			except:
60			return entries
61			for line in vdbfile.readlines():
62			parts = line.strip().split(" ")
63			if parts[0] == "obj":
64			entries.append(parts[1])
65	agaffney	1222	# elif parts[0] == "dir":
66			# entries.append(parts[1] + "/")
67	agaffney	1221	elif parts[0] == "sym":
68			entries.append(" ".join(parts[1:4]))
69			entries.sort()
70			return entries
71
72	agaffney	1280	def copy_pkg_to_chroot(self, package, use_root=False, ignore_missing=False):
73	agaffney	1221	symlinks = { '/bin': '/mnt/livecd/bin/', '/boot': '/mnt/livecd/boot/', '/lib': '/mnt/livecd/lib/',
74			'/opt': '/mnt/livecd/opt/', '/sbin': '/mnt/livecd/sbin/', '/usr': '/mnt/livecd/usr/',
75			'/etc/gconf': '/usr/livecd/gconf/' }
76	agaffney	1182
77	agaffney	1208	tmpdir = "/var/tmp/portage"
78			image_dir = tmpdir + "/" + package.split("/")[1] + "/image"
79	agaffney	1198	root_cmd = ""
80			tmp_chroot_dir = self._chroot_dir
81	agaffney	1204	portage_tmpdir = "/var/tmp/portage"
82	agaffney	1270	vdb_dir = "/var/db/pkg/"
83	agaffney	1198	if use_root:
84			root_cmd = "ROOT=" + self._chroot_dir
85	agaffney	1203	tmp_chroot_dir = ""
86	agaffney	1204	portage_tmpdir = self._chroot_dir + "/var/tmp/portage"
87	agaffney	1270	vdb_dir = self._chroot_dir + "/var/db/pkg/"
88	agaffney	1198
89	agaffney	1280	# Check to see if package is actually in vdb
90			if not GLIUtility.is_file("/var/db/pkg/" + package):
91			if ignore_missing:
92			if self._debug:
93			self._logger.log("DEBUG: copy_pkg_to_chroot(): package " + package + " does not have a vdb entry but ignore_missing=True...ignoring error")
94			return
95			else:
96			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "There is no vdb entry for " + package)
97
98	agaffney	1182	# Copy the vdb entry for the package from the LiveCD to the chroot
99			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying vdb entry for " + package)
100			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)):
101			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy vdb entry for " + package)
102
103	agaffney	1208	# Create the image dir in the chroot
104			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running 'mkdir -p " + self._chroot_dir + image_dir + "'")
105			if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir -p " + self._chroot_dir + image_dir)):
106			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create image dir for " + package)
107
108	agaffney	1182	# Create list of files for tar to work with from CONTENTS file in vdb entry
109	agaffney	1221	entries = self.parse_vdb_contents("/var/db/pkg/" + package + "/CONTENTS")
110	agaffney	1208	if not entries:
111			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping tar and symlink fixup")
112			else:
113			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot: files for " + package + ": " + str(entries))
114			try:
115			tarfiles = open("/tmp/tarfilelist", "w")
116			for entry in entries:
117			parts = entry.split(" ")
118	agaffney	1222	# # Hack for symlink crappiness
119	agaffney	1221	# for symlink in symlinks:
120			# if parts[0].startswith(symlink):
121			# parts[0] = symlinks[symlink] + parts[0][len(symlink):]
122	agaffney	1208	tarfiles.write(parts[0] + "\n")
123			tarfiles.close()
124			except:
125			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create filelist for " + package)
126	agaffney	1182
127	agaffney	1208	# Use tar to transfer files into IMAGE directory
128	agaffney	1222	if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running 'tar -cp --files-from=/tmp/tarfilelist --no-recursion 2>/dev/null \| tar -C " + self._chroot_dir + image_dir + " -xp'")
129			if not GLIUtility.exitsuccess(GLIUtility.spawn("tar -cp --files-from=/tmp/tarfilelist --no-recursion 2>/dev/null \| tar -C " + self._chroot_dir + image_dir + " -xp")):
130	agaffney	1208	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute tar for " + package)
131	agaffney	1182
132	agaffney	1221	# # More symlink crappiness hacks
133			# for symlink in symlinks:
134			## if GLIUtility.is_file(self._chroot_dir + image_dir + symlinks[symlink]):
135			# if os.path.islink(self._chroot_dir + image_dir + symlink):
136			# if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): fixing " + symlink + " symlink ickiness stuff in " + image_dir + " for " + package)
137			# GLIUtility.spawn("rm " + self._chroot_dir + image_dir + symlink)
138			# if not GLIUtility.exitsuccess(GLIUtility.spawn("mv " + self._chroot_dir + image_dir + symlinks[symlink] + " " + self._chroot_dir + image_dir + symlink)):
139			# raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not fix " + symlink + " symlink ickiness for " + package)
140	agaffney	1182
141			# Run pkg_setup
142			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running pkg_setup for " + package)
143	agaffney	1269	if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " ebuild " + vdb_dir + package + "/*.ebuild setup", chroot=tmp_chroot_dir)):
144	agaffney	1182	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute pkg_setup for " + package)
145
146			# Run pkg_preinst
147			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running preinst for " + package)
148	agaffney	1269	if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " ebuild " + vdb_dir + package + "/*.ebuild preinst", chroot=tmp_chroot_dir)):
149	agaffney	1182	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute preinst for " + package)
150
151			# Copy files from image_dir to chroot
152	agaffney	1208	if not entries:
153	agaffney	1209	if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping copy from image dir to /")
154	agaffney	1208	else:
155			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying files from " + image_dir + " to / for " + package)
156	agaffney	1291	# if not GLIUtility.exitsuccess(GLIUtility.spawn("cp -a " + self._chroot_dir + image_dir + "/* " + self._chroot_dir)):
157			if not GLIUtility.exitsuccess(GLIUtility.spawn("tar -C " + self._chroot_dir + image_dir + "/ -c . \| tar -C " + self._chroot_dir + "/ -x")):
158	agaffney	1208	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy files from " + image_dir + " to / for " + package)
159	agaffney	1182
160			# Run pkg_postinst
161			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running postinst for " + package)
162	agaffney	1269	if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " ebuild " + vdb_dir + package + "/*.ebuild postinst", chroot=tmp_chroot_dir)):
163	agaffney	1182	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute postinst for " + package)
164
165			# Remove image_dir
166	agaffney	1208	if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): removing " + image_dir + " for " + package)
167	agaffney	1182	if not GLIUtility.exitsuccess(GLIUtility.spawn("rm -rf " + self._chroot_dir + image_dir)):
168			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not remove + " + image_dir + " for " + package)
169
170	agaffney	1297	# Run env-update
171			if not use_root:
172			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running env-update inside chroot")
173	agaffney	1298	if not GLIUtility.exitsuccess(GLIUtility.spawn("env-update", chroot=self._chroot_dir)):
174	agaffney	1297	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not run env-update for " + package)
175
176	agaffney	1182	def add_pkg_to_world(self, package):
177			if package.find("/") == -1:
178	agaffney	1195	package = self.get_best_version_vdb_chroot(package)
179	agaffney	1182	if not package: return False
180	agaffney	1205	expr = re.compile('^=?(.+?/.+?)(-\d.+)?$')
181	agaffney	1182	res = expr.match(package)
182			if res:
183			GLIUtility.spawn("echo " + res.group(1) + " >> " + self._chroot_dir + "/var/lib/portage/world")
184
185	agaffney	1185	def get_best_version_vdb(self, package):
186	agaffney	1285	if package.startswith('='):
187			package = package[1:]
188			if GLIUtility.is_file("/var/db/pkg/" + package):
189			return package
190	agaffney	1286	else:
191			return ""
192	agaffney	1285	else:
193			return GLIUtility.spawn("portageq best_version / " + package, return_output=True)[1].strip()
194	agaffney	1189
195	agaffney	1194	def get_best_version_vdb_chroot(self, package):
196	agaffney	1287	if package.startswith('='):
197			package = package[1:]
198			if GLIUtility.is_file(self._chroot_dir + "/var/db/pkg/" + package):
199			return package
200			else:
201			return ""
202			else:
203			return GLIUtility.spawn("portageq best_version / " + package, chroot=self._chroot_dir, return_output=True)[1].strip()
204	agaffney	1194
205	agaffney	1184	# def get_best_version_tree(self, package):
206			# return portage.best(tree.match(package))
207	agaffney	1205
208			def emerge(self, packages, add_to_world=True):
209			if isinstance(packages, str):
210			packages = packages.split()
211	agaffney	1223	self._cc.addNotification("progress", (0, "Calculating dependencies for " + " ".join(packages)))
212	agaffney	1205	pkglist = self.get_deps(packages)
213			if self._debug: self._logger.log("install_packages(): pkglist is " + str(pkglist))
214			for i, pkg in enumerate(pkglist):
215	agaffney	1305	if not pkg: continue
216	agaffney	1205	if self._debug: self._logger.log("install_packages(): processing package " + pkg)
217	agaffney	1208	self._cc.addNotification("progress", (float(i) / len(pkglist), "Emerging " + pkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")"))
218			if not self._grp_install or not self.get_best_version_vdb("=" + pkg):
219	agaffney	1205	status = GLIUtility.spawn("emerge -1 =" + pkg, display_on_tty8=True, chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)
220			# status = self._emerge("=" + pkg)
221			if not GLIUtility.exitsuccess(status):
222			raise GLIException("EmergePackageError", "fatal", "emerge", "Could not emerge " + pkg + "!")
223			else:
224			# try:
225			self.copy_pkg_to_chroot(pkg)
226			# except:
227			# raise GLIException("EmergePackageError", "fatal", "emerge", "Could not emerge " + pkg + "!")
228	agaffney	1208	self._cc.addNotification("progress", (float(i+1) / len(pkglist), "Done emerging " + pkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")"))
229	agaffney	1205	if add_to_world:
230			for package in packages:
231			self.add_pkg_to_world(package)