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.8 2005/12/26 02:50:37 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 " + tmmpkg + " is already in pkglist")
                                if not tmppkg in pkglist:
                                        if self._debug: self._logger.log("get_deps(): adding " + tmmpkg + " 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_tree(self, package):
#               return portage.best(tree.match(package))
1	"""
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	$Id: GLIPortage.py,v 1.8 2005/12/26 02:50:37 agaffney Exp $
9	"""
10
11	import re
12	import GLIUtility
13	import GLIException
14
15	class GLIPortage(object):
16
17	def __init__(self, chroot_dir, grp_install, logger, debug):
18	self._chroot_dir = chroot_dir
19	self._grp_install = grp_install
20	self._logger = logger
21	self._debug = debug
22
23	def get_deps(self, pkgs):
24	pkglist = []
25	if isinstance(pkgs, str):
26	pkgs = pkgs.split()
27	for pkg in pkgs:
28	if self._debug: self._logger.log("get_deps(): pkg is " + pkg)
29	if not self._grp_install or not self.get_best_version_vdb(pkg):
30	if self._debug: self._logger.log("get_deps(): grabbing compile deps")
31	# del(os.environ['ROOT'])
32	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	# os.environ['ROOT'] = self._chroot_dir
34	else:
35	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	for tmppkg in tmppkglist:
39	if self._debug: self._logger.log("get_deps(): checking to see if " + tmmpkg + " is already in pkglist")
40	if not tmppkg in pkglist:
41	if self._debug: self._logger.log("get_deps(): adding " + tmmpkg + " to pkglist")
42	pkglist.append(tmppkg)
43	if self._debug: self._logger.log("get_deps(): pkglist is " + str(pkglist))
44	return pkglist
45
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	def get_best_version_vdb(self, package):
127	return GLIUtility.spawn("portageq best_version / " + package, return_output=True)[1].strip()
128
129	# def get_best_version_tree(self, package):
130	# return portage.best(tree.match(package))