""" # 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.2 2005/12/23 22:32:57 agaffney Exp $ """ import os import re import GLIUtility class MissingPackagesError(Exception): pass class depgraph: def __init__(self): self.graph = {} def add(self, node, parent=None): if node not in self.graph: self.graph[node] = [[], []] if parent and parent not in self.graph[node][0]: if parent not in self.graph: self.graph[parent] = [[], []] self.graph[node][0].append(parent) self.graph[parent][1].append(node) def remove(self, node): for parent in self.graph[node][0]: self.graph[parent][1].remove(node) for child in self.graph[node][1]: self.graph[child][0].remove(node) return self.graph.pop(node) def has_node(self, node): return node in self.graph def leaf_nodes(self): return [node for node in self.graph if not self.graph[node][1]] def node_count(self): return len(self.graph) def important_node(self): important_node = None importance = 0 for node in self.graph: if len(self.graph[node][0]) > importance: importance = len(self.graph[node][0]) important_node = node return important_node class GLIPortage(object): def __init__(self, chroot_dir, logger, debug): os.environ['ROOT'] = chroot_dir import portage, portage_dep self.vdb = portage.db["/"]["vartree"].dbapi self.tree = portage.db[chroot_dir]["porttree"].dbapi self._chroot_dir = chroot_dir self._logger = logger self._debug = debug def resolve_deps(self, dep_list): if dep_list and dep_list[0] == "||": for dep in dep_list[1:]: if isinstance(dep, list): try: atoms = resolve_deps(dep) except MissingPackagesError: continue else: atoms = [dep] all_found = True for atom in atoms: if not atom.startswith("!") and not self.vdb.match(atom): all_found = False break if all_found: return atoms raise MissingPackagesError(dep_list) atoms = [] for dep in dep_list: if isinstance(dep, list): atoms.extend(resolve_deps(dep)) elif not dep.startswith("!"): if not self.vdb.match(dep): raise MissingPackagesError([dep]) atoms.append(dep) return atoms def calc_required_pkgs(self, atom, graph, parent=None): pkg = portage.best(self.vdb.match(atom)) if not pkg: raise MissingPackagesError([atom]) if pkg == parent: return already_processed = graph.has_node(pkg) graph.add(pkg, parent) if already_processed: return useflags = self.vdb.aux_get(pkg, ["USE"])[0].split() rdep_raw = " ".join(self.vdb.aux_get(pkg, ["RDEPEND", "PDEPEND"])) rdep_struct = portage_dep.use_reduce(portage_dep.paren_reduce(rdep_raw), uselist=useflags) rdep_struct = portage.dep_virtual(portage_dep.dep_opconvert(rdep_struct), portage.settings) rdep_atoms = portage.unique_array(resolve_deps(rdep_struct)) for atom in rdep_atoms: calc_required_pkgs(atom, graph, pkg) def prune_existing(self, graph): db = portage.db[portage.root]["vartree"].dbapi for atom in db.cp_all(): for pkg in db.match(atom): if graph.has_node(pkg): graph.remove(pkg) def get_deps(self, pkgs, grp_install): if not grp_install: del(os.environ['ROOT']) return 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].split("\n") os.environ['ROOT'] = self._chroot_dir else: pkglist = [] graph = depgraph() for pkg in pkgs.split(): if not self.vdb.match(pkg): self._logger.log("get_deps(): " + pkg + " is not available via GRP...ignoring") continue self.calc_required_pkgs(pkg, graph) while graph.node_count(): leaf_nodes = graph.leaf_nodes() if not leaf_nodes: node = graph.important_node() pkglist.append(node) graph.remove(node) continue pkglist.extend(leaf_nodes) for node in leaf_nodes: graph.remove(node) 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 portage.best(vdb.match(package)) def get_best_version_tree(self, package): return portage.best(tree.match(package))