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.16 2006/01/01 02:03:52 agaffney Exp $
"""

import re
import GLIUtility
import GLIException

class GLIPortage(object):

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

        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")
#                               del(os.environ['ROOT'])
                                tmppkglist = GLIUtility.spawn("emerge -p " + pkgs + r" | grep -e '^\[[a-z]' | cut -d ']' -f2 | sed -e 's:^ ::' -e 's: .\+$::'", chroot=self._chroot_dir, return_output=True)[1].strip().split("\n")
#                               os.environ['ROOT'] = self._chroot_dir
                        else:
                                if self._debug: self._logger.log("get_deps(): grabbing binary deps")
                                tmppkglist = GLIUtility.spawn("python ../../runtimedeps.py " + self._chroot_dir + " " + pkg, return_output=True)[1].strip().split("\n")
                        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/' }

                root_cmd = ""
                tmp_chroot_dir = self._chroot_dir
                if use_root:
                        root_cmd = "ROOT=" + self._chroot_dir
                        tmp_chroot_dir = None

                # 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 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 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
                tmpdir = "/var/tmp/portage"
                image_dir = tmpdir + "/" + package.split("/")[1] + "/image"
                if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running 'mkdir -p " + self._chroot_dir + image_dir + " && 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("mkdir -p " + self._chroot_dir + image_dir + " && 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]):
#                               parts[0] = symlinks[symlink] + parts[len(symlink):]
                                if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): fixing /usr/livecd/gconf/ stuff in " + image_dir + " 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 /usr/livecd/gconf/ stuff 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=" + tmp_chroot_dir + 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 qmerge
#               if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running qmerge for " + package)
#               if not GLIUtility.exitsuccess(GLIUtility.spawn("env ROOT=" + self._chroot_dir + " PORTAGE_TMPDIR=" + self._chroot_dir + tmpdir + " ebuild " + self._chroot_dir + "/var/db/pkg/" + package + "/*.ebuild qmerge")):
#                       raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute qmerge 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=" + tmp_chroot_dir + 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 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=" + tmp_chroot_dir + 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))
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	1202	$Id: GLIPortage.py,v 1.16 2006/01/01 02:03:52 agaffney Exp $
9	agaffney	1181	"""
10
11	agaffney	1182	import re
12	agaffney	1181	import GLIUtility
13	agaffney	1189	import GLIException
14	agaffney	1181
15			class GLIPortage(object):
16
17	agaffney	1183	def __init__(self, chroot_dir, grp_install, logger, debug):
18	agaffney	1182	self._chroot_dir = chroot_dir
19	agaffney	1189	self._grp_install = grp_install
20	agaffney	1182	self._logger = logger
21			self._debug = debug
22	agaffney	1181
23	agaffney	1183	def get_deps(self, pkgs):
24	agaffney	1189	pkglist = []
25			if isinstance(pkgs, str):
26			pkgs = pkgs.split()
27			for pkg in pkgs:
28	agaffney	1190	if self._debug: self._logger.log("get_deps(): pkg is " + pkg)
29	agaffney	1189	if not self._grp_install or not self.get_best_version_vdb(pkg):
30	agaffney	1190	if self._debug: self._logger.log("get_deps(): grabbing compile deps")
31	agaffney	1189	# del(os.environ['ROOT'])
32	agaffney	1190	tmppkglist = GLIUtility.spawn("emerge -p " + pkgs + r" \| grep -e '^\[[a-z]' \| cut -d ']' -f2 \| sed -e 's:^ ::' -e 's: .\+$::'", chroot=self._chroot_dir, return_output=True)[1].strip().split("\n")
33	agaffney	1189	# os.environ['ROOT'] = self._chroot_dir
34			else:
35	agaffney	1190	if self._debug: self._logger.log("get_deps(): grabbing binary deps")
36	agaffney	1200	tmppkglist = GLIUtility.spawn("python ../../runtimedeps.py " + self._chroot_dir + " " + pkg, return_output=True)[1].strip().split("\n")
37	agaffney	1190	if self._debug: self._logger.log("get_deps(): deplist for " + pkg + ": " + str(tmppkglist))
38	agaffney	1189	for tmppkg in tmppkglist:
39	agaffney	1192	if self._debug: self._logger.log("get_deps(): checking to see if " + tmppkg + " is already in pkglist")
40	agaffney	1194	if not tmppkg in pkglist and not self.get_best_version_vdb_chroot("=" + tmppkg):
41	agaffney	1192	if self._debug: self._logger.log("get_deps(): adding " + tmppkg + " to pkglist")
42	agaffney	1189	pkglist.append(tmppkg)
43	agaffney	1190	if self._debug: self._logger.log("get_deps(): pkglist is " + str(pkglist))
44	agaffney	1189	return pkglist
45	agaffney	1182
46	agaffney	1199	def copy_pkg_to_chroot(self, package, use_root=False):
47	agaffney	1182	symlinks = { '/bin/': '/mnt/livecd/bin/', '/boot/': '/mnt/livecd/boot/', '/lib/': '/mnt/livecd/lib/',
48			'/opt/': '/mnt/livecd/opt/', '/sbin/': '/mnt/livecd/sbin/', '/usr/': '/mnt/livecd/usr/',
49			'/etc/gconf/': '/usr/livecd/gconf/' }
50
51	agaffney	1198	root_cmd = ""
52			tmp_chroot_dir = self._chroot_dir
53			if use_root:
54			root_cmd = "ROOT=" + self._chroot_dir
55			tmp_chroot_dir = None
56
57	agaffney	1182	# Copy the vdb entry for the package from the LiveCD to the chroot
58			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying vdb entry for " + package)
59			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)):
60			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy vdb entry for " + package)
61
62			# Create list of files for tar to work with from CONTENTS file in vdb entry
63			entries = GLIUtility.parse_vdb_contents("/var/db/pkg/" + package + "/CONTENTS")
64			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot: files for " + package + ": " + str(entries))
65			try:
66			tarfiles = open("/tmp/tarfilelist", "w")
67			for entry in entries:
68			parts = entry.split(" ")
69			# Hack for symlink crappiness
70			for symlink in symlinks:
71			if parts[0].startswith(symlink):
72			parts[0] = symlinks[symlink] + parts[0][len(symlink):]
73			tarfiles.write(parts[0] + "\n")
74			tarfiles.close()
75			except:
76			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create filelist for " + package)
77
78			# Use tar to transfer files into IMAGE directory
79			tmpdir = "/var/tmp/portage"
80			image_dir = tmpdir + "/" + package.split("/")[1] + "/image"
81			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running 'mkdir -p " + self._chroot_dir + image_dir + " && tar -c --files-from=/tmp/tarfilelist --no-recursion 2>/dev/null \| tar -C " + self._chroot_dir + image_dir + " -x'")
82			if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir -p " + self._chroot_dir + image_dir + " && tar -c --files-from=/tmp/tarfilelist --no-recursion 2>/dev/null \| tar -C " + self._chroot_dir + image_dir + " -x")):
83			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute tar for " + package)
84
85			# More symlink crappiness hacks
86			for symlink in symlinks:
87			if GLIUtility.is_file(self._chroot_dir + image_dir + symlinks[symlink]):
88			# parts[0] = symlinks[symlink] + parts[len(symlink):]
89			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): fixing /usr/livecd/gconf/ stuff in " + image_dir + " for " + package)
90			if not GLIUtility.exitsuccess(GLIUtility.spawn("mv " + self._chroot_dir + image_dir + symlinks[symlink] + " " + self._chroot_dir + image_dir + symlink)):
91			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not fix /usr/livecd/gconf/ stuff for " + package)
92
93			# Run pkg_setup
94			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running pkg_setup for " + package)
95	agaffney	1202	if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + tmp_chroot_dir + tmpdir + " ebuild /var/db/pkg/" + package + "/*.ebuild setup", chroot=tmp_chroot_dir)):
96	agaffney	1182	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute pkg_setup for " + package)
97
98			# Run qmerge
99			# if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running qmerge for " + package)
100			# if not GLIUtility.exitsuccess(GLIUtility.spawn("env ROOT=" + self._chroot_dir + " PORTAGE_TMPDIR=" + self._chroot_dir + tmpdir + " ebuild " + self._chroot_dir + "/var/db/pkg/" + package + "/*.ebuild qmerge")):
101			# raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute qmerge for " + package)
102
103			# Run pkg_preinst
104			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running preinst for " + package)
105	agaffney	1202	if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + tmp_chroot_dir + tmpdir + " ebuild /var/db/pkg/" + package + "/*.ebuild preinst", chroot=tmp_chroot_dir)):
106	agaffney	1182	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute preinst for " + package)
107
108			# Copy files from image_dir to chroot
109			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying files from " + image_dir + " to / for " + package)
110			if not GLIUtility.exitsuccess(GLIUtility.spawn("cp -a " + self._chroot_dir + image_dir + "/* " + self._chroot_dir)):
111			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy files from " + image_dir + " to / for " + package)
112
113			# Run pkg_postinst
114			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running postinst for " + package)
115	agaffney	1202	if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + tmp_chroot_dir + tmpdir + " ebuild /var/db/pkg/" + package + "/*.ebuild postinst", chroot=tmp_chroot_dir)):
116	agaffney	1182	raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute postinst for " + package)
117
118			# Remove image_dir
119			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): removing + " + image_dir + " for " + package)
120			if not GLIUtility.exitsuccess(GLIUtility.spawn("rm -rf " + self._chroot_dir + image_dir)):
121			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not remove + " + image_dir + " for " + package)
122
123			def add_pkg_to_world(self, package):
124			if package.find("/") == -1:
125	agaffney	1195	package = self.get_best_version_vdb_chroot(package)
126	agaffney	1182	if not package: return False
127			expr = re.compile('^(.+?)(-\d.+)?$')
128			res = expr.match(package)
129			if res:
130			GLIUtility.spawn("echo " + res.group(1) + " >> " + self._chroot_dir + "/var/lib/portage/world")
131
132	agaffney	1185	def get_best_version_vdb(self, package):
133			return GLIUtility.spawn("portageq best_version / " + package, return_output=True)[1].strip()
134	agaffney	1189
135	agaffney	1194	def get_best_version_vdb_chroot(self, package):
136	agaffney	1195	return GLIUtility.spawn("portageq best_version / " + package, chroot=self._chroot_dir, return_output=True)[1].strip()
137	agaffney	1194
138	agaffney	1184	# def get_best_version_tree(self, package):
139			# return portage.best(tree.match(package))