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.10 2005/12/26 06:16:05 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("env ROOT='" + self._chroot_dir + "' python ../../runtimedeps.py " + 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):
                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/' }

                # 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=" + self._chroot_dir + " PORTAGE_TMPDIR=" + self._chroot_dir + tmpdir + "  ebuild " + self._chroot_dir + "/var/db/pkg/" + package + "/*.ebuild setup")):
                        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=" + self._chroot_dir + " PORTAGE_TMPDIR=" + self._chroot_dir + tmpdir + " ebuild " + self._chroot_dir + "/var/db/pkg/" + package + "/*.ebuild preinst")):
                        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=" + self._chroot_dir + " PORTAGE_TMPDIR=" + self._chroot_dir + tmpdir + " ebuild " + "/var/db/pkg/" + package + "/*.ebuild postinst")):
                        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 = GLIUtility.spawn("portageq best_version / " + package, chroot=self._chroot_dir, return_output=True)[1].strip()
                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 " + self._chroot_dir + " " + package, 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	1194	$Id: GLIPortage.py,v 1.10 2005/12/26 06:16:05 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			tmppkglist = GLIUtility.spawn("env ROOT='" + self._chroot_dir + "' python ../../runtimedeps.py " + pkg, return_output=True)[1].strip().split("\n")
37			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			def copy_pkg_to_chroot(self, package):
47			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			# Copy the vdb entry for the package from the LiveCD to the chroot
52			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying vdb entry for " + package)
53			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)):
54			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy vdb entry for " + package)
55
56			# Create list of files for tar to work with from CONTENTS file in vdb entry
57			entries = GLIUtility.parse_vdb_contents("/var/db/pkg/" + package + "/CONTENTS")
58			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot: files for " + package + ": " + str(entries))
59			try:
60			tarfiles = open("/tmp/tarfilelist", "w")
61			for entry in entries:
62			parts = entry.split(" ")
63			# Hack for symlink crappiness
64			for symlink in symlinks:
65			if parts[0].startswith(symlink):
66			parts[0] = symlinks[symlink] + parts[0][len(symlink):]
67			tarfiles.write(parts[0] + "\n")
68			tarfiles.close()
69			except:
70			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create filelist for " + package)
71
72			# Use tar to transfer files into IMAGE directory
73			tmpdir = "/var/tmp/portage"
74			image_dir = tmpdir + "/" + package.split("/")[1] + "/image"
75			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'")
76			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")):
77			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute tar for " + package)
78
79			# More symlink crappiness hacks
80			for symlink in symlinks:
81			if GLIUtility.is_file(self._chroot_dir + image_dir + symlinks[symlink]):
82			# parts[0] = symlinks[symlink] + parts[len(symlink):]
83			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): fixing /usr/livecd/gconf/ stuff in " + image_dir + " for " + package)
84			if not GLIUtility.exitsuccess(GLIUtility.spawn("mv " + self._chroot_dir + image_dir + symlinks[symlink] + " " + self._chroot_dir + image_dir + symlink)):
85			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not fix /usr/livecd/gconf/ stuff for " + package)
86
87			# Run pkg_setup
88			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running pkg_setup for " + package)
89			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 setup")):
90			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute pkg_setup for " + package)
91
92			# Run qmerge
93			# if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running qmerge for " + package)
94			# 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")):
95			# raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute qmerge for " + package)
96
97			# Run pkg_preinst
98			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running preinst for " + package)
99			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 preinst")):
100			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute preinst for " + package)
101
102			# Copy files from image_dir to chroot
103			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying files from " + image_dir + " to / for " + package)
104			if not GLIUtility.exitsuccess(GLIUtility.spawn("cp -a " + self._chroot_dir + image_dir + "/* " + self._chroot_dir)):
105			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy files from " + image_dir + " to / for " + package)
106
107			# Run pkg_postinst
108			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running postinst for " + package)
109			if not GLIUtility.exitsuccess(GLIUtility.spawn("env ROOT=" + self._chroot_dir + " PORTAGE_TMPDIR=" + self._chroot_dir + tmpdir + " ebuild " + "/var/db/pkg/" + package + "/*.ebuild postinst")):
110			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute postinst for " + package)
111
112			# Remove image_dir
113			if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): removing + " + image_dir + " for " + package)
114			if not GLIUtility.exitsuccess(GLIUtility.spawn("rm -rf " + self._chroot_dir + image_dir)):
115			raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not remove + " + image_dir + " for " + package)
116
117			def add_pkg_to_world(self, package):
118			if package.find("/") == -1:
119			package = GLIUtility.spawn("portageq best_version / " + package, chroot=self._chroot_dir, return_output=True)[1].strip()
120			if not package: return False
121			expr = re.compile('^(.+?)(-\d.+)?$')
122			res = expr.match(package)
123			if res:
124			GLIUtility.spawn("echo " + res.group(1) + " >> " + self._chroot_dir + "/var/lib/portage/world")
125
126	agaffney	1185	def get_best_version_vdb(self, package):
127			return GLIUtility.spawn("portageq best_version / " + package, return_output=True)[1].strip()
128	agaffney	1189
129	agaffney	1194	def get_best_version_vdb_chroot(self, package):
130			return GLIUtility.spawn("portageq best_version " + self._chroot_dir + " " + package, return_output=True)[1].strip()
131
132	agaffney	1184	# def get_best_version_tree(self, package):
133			# return portage.best(tree.match(package))