| 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.57 2006/09/13 18:29:13 agaffney Exp $ |
| 9 |
""" |
| 10 |
|
| 11 |
import re |
| 12 |
import os |
| 13 |
import sys |
| 14 |
import GLIUtility |
| 15 |
from GLIException import GLIException |
| 16 |
|
| 17 |
class GLIPortage(object): |
| 18 |
|
| 19 |
def __init__(self, chroot_dir, logger, debug, cc, compile_logfile): |
| 20 |
self._chroot_dir = chroot_dir |
| 21 |
self._logger = logger |
| 22 |
self._debug = debug |
| 23 |
self._cc = cc |
| 24 |
self._compile_logfile = compile_logfile |
| 25 |
|
| 26 |
def get_deps(self, pkgs, grp_install=False): |
| 27 |
pkglist = [] |
| 28 |
if isinstance(pkgs, str): |
| 29 |
pkgs = pkgs.split() |
| 30 |
for pkg in pkgs: |
| 31 |
if not pkg: continue |
| 32 |
if self._debug: self._logger.log("get_deps(): pkg is " + pkg) |
| 33 |
if not grp_install or not self.get_best_version_vdb(pkg): |
| 34 |
if self._debug: self._logger.log("get_deps(): grabbing compile deps") |
| 35 |
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 |
else: |
| 37 |
if self._debug: self._logger.log("get_deps(): grabbing binary deps") |
| 38 |
# 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 |
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 |
if self._debug: self._logger.log("get_deps(): looking at " + tmppkg) |
| 43 |
if self.get_best_version_vdb("=" + tmppkg): |
| 44 |
if self._debug: self._logger.log("get_deps(): package " + tmppkg + " in host vdb...adding to tmppkglist") |
| 45 |
tmppkglist.append(tmppkg) |
| 46 |
if self._debug: self._logger.log("get_deps(): deplist for " + pkg + ": " + str(tmppkglist)) |
| 47 |
for tmppkg in tmppkglist: |
| 48 |
if self._debug: self._logger.log("get_deps(): checking to see if " + tmppkg + " is already in pkglist") |
| 49 |
if not tmppkg in pkglist and not self.get_best_version_vdb_chroot("=" + tmppkg): |
| 50 |
if self._debug: self._logger.log("get_deps(): adding " + tmppkg + " to pkglist") |
| 51 |
pkglist.append(tmppkg) |
| 52 |
if self._debug: self._logger.log("get_deps(): pkglist is " + str(pkglist)) |
| 53 |
if not pkglist: |
| 54 |
raise GLIException("GetDepListError", 'fatal', 'get_deps', "Dep list is empty. This usually means there is no portage tree in the chroot") |
| 55 |
return pkglist |
| 56 |
|
| 57 |
def parse_vdb_contents(self, file): |
| 58 |
entries = [] |
| 59 |
try: |
| 60 |
vdbfile = open(file, "r") |
| 61 |
except: |
| 62 |
return entries |
| 63 |
for line in vdbfile.readlines(): |
| 64 |
parts = line.strip().split(" ") |
| 65 |
if parts[0] == "obj": |
| 66 |
entries.append(parts[1]) |
| 67 |
# elif parts[0] == "dir": |
| 68 |
# entries.append(parts[1] + "/") |
| 69 |
elif parts[0] == "sym": |
| 70 |
entries.append(" ".join(parts[1:4])) |
| 71 |
entries.sort() |
| 72 |
return entries |
| 73 |
|
| 74 |
def update_counter(self): |
| 75 |
try: |
| 76 |
counter_f = open(self._chroot_dir + "/var/cache/edb/counter", "r") |
| 77 |
counter = int(counter_f.readline().strip()) |
| 78 |
counter_f.close() |
| 79 |
except: |
| 80 |
counter = 0 |
| 81 |
counter += 1 |
| 82 |
if not os.path.isdir(self._chroot_dir + "/var"): |
| 83 |
os.mkdir(self._chroot_dir + "/var", 0755) |
| 84 |
if not os.path.isdir(self._chroot_dir + "/var/cache"): |
| 85 |
os.mkdir(self._chroot_dir + "/var/cache", 0755) |
| 86 |
if not os.path.isdir(self._chroot_dir + "/var/cache/edb"): |
| 87 |
os.mkdir(self._chroot_dir + "/var/cache/edb", 0775) |
| 88 |
# chown to root:portage |
| 89 |
try: |
| 90 |
counter_f = open(self._chroot_dir + "/var/cache/edb/counter", "w") |
| 91 |
counter_f.write(str(counter)) |
| 92 |
counter_f.close() |
| 93 |
except: |
| 94 |
raise GLIException("UpdateCounterError", 'fatal', 'update_counter', "could not write new counter value") |
| 95 |
return counter |
| 96 |
|
| 97 |
def copy_pkg_to_chroot(self, package, use_root=False, ignore_missing=False): |
| 98 |
symlinks = { '/bin': '/mnt/livecd/bin/', '/boot': '/mnt/livecd/boot/', '/lib': '/mnt/livecd/lib/', |
| 99 |
'/opt': '/mnt/livecd/opt/', '/sbin': '/mnt/livecd/sbin/', '/usr': '/mnt/livecd/usr/', |
| 100 |
'/etc/gconf': '/usr/livecd/gconf/' } |
| 101 |
|
| 102 |
tmpdir = "/var/tmp" |
| 103 |
image_dir = tmpdir + "/portage/" + package + "/image" |
| 104 |
root_cmd = "" |
| 105 |
tmp_chroot_dir = self._chroot_dir |
| 106 |
portage_tmpdir = "/var/tmp" |
| 107 |
vdb_dir = "/var/db/pkg/" |
| 108 |
if use_root: |
| 109 |
root_cmd = "ROOT=" + self._chroot_dir |
| 110 |
tmp_chroot_dir = "" |
| 111 |
portage_tmpdir = self._chroot_dir + "/var/tmp" |
| 112 |
vdb_dir = self._chroot_dir + "/var/db/pkg/" |
| 113 |
|
| 114 |
# Create /tmp, /var/tmp, and /var/lib/portage with proper permissions |
| 115 |
oldumask = os.umask(0) |
| 116 |
if not os.path.exists(self._chroot_dir + "/tmp"): |
| 117 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): /tmp doesn't exist in chroot...creating with proper permissions") |
| 118 |
try: |
| 119 |
os.mkdir(self._chroot_dir + "/tmp", 01777) |
| 120 |
except: |
| 121 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Failed to create /tmp in chroot") |
| 122 |
if not os.path.exists(self._chroot_dir + "/var/tmp"): |
| 123 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): /var/tmp doesn't exist in chroot...creating with proper permissions") |
| 124 |
try: |
| 125 |
os.mkdir(self._chroot_dir + "/var", 0755) |
| 126 |
except: |
| 127 |
pass |
| 128 |
try: |
| 129 |
os.mkdir(self._chroot_dir + "/var/tmp", 01777) |
| 130 |
except: |
| 131 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Failed to create /var/tmp in chroot") |
| 132 |
if not os.path.exists(self._chroot_dir + "/var/lib/portage"): |
| 133 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): /var/lib/portage doesn't exist in chroot...creating with proper permissions") |
| 134 |
try: |
| 135 |
os.mkdir(self._chroot_dir + "/var/lib", 0755) |
| 136 |
except: |
| 137 |
pass |
| 138 |
try: |
| 139 |
os.mkdir(self._chroot_dir + "/var/lib/portage", 02750) |
| 140 |
except: |
| 141 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Failed to create /var/lib/portage in chroot") |
| 142 |
os.umask(oldumask) |
| 143 |
|
| 144 |
# Check to see if package is actually in vdb |
| 145 |
if not GLIUtility.is_file("/var/db/pkg/" + package): |
| 146 |
if ignore_missing: |
| 147 |
if self._debug: |
| 148 |
self._logger.log("DEBUG: copy_pkg_to_chroot(): package " + package + " does not have a vdb entry but ignore_missing=True...ignoring error") |
| 149 |
return |
| 150 |
else: |
| 151 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "There is no vdb entry for " + package) |
| 152 |
|
| 153 |
# Copy the vdb entry for the package from the LiveCD to the chroot |
| 154 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying vdb entry for " + package) |
| 155 |
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, logfile=self._compile_logfile, append_log=True)): |
| 156 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy vdb entry for " + package) |
| 157 |
|
| 158 |
# Update COUNTER |
| 159 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): calling update_counter() to get updated COUNTER value for " + package) |
| 160 |
counter = self.update_counter() |
| 161 |
try: |
| 162 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): updating COUNTER value (%s) in vdb entry for %s" % (self._chroot_dir + "/var/db/pkg/" + package + "/COUNTER", package)) |
| 163 |
counter_f = open(self._chroot_dir + "/var/db/pkg/" + package + "/COUNTER", "w") |
| 164 |
counter_f.write(str(counter)) |
| 165 |
counter_f.close() |
| 166 |
except: |
| 167 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not update COUNTER for " + package) |
| 168 |
|
| 169 |
# Create the image dir in the chroot |
| 170 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running 'mkdir -p " + self._chroot_dir + image_dir + "'") |
| 171 |
if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir -p " + self._chroot_dir + image_dir, logfile=self._compile_logfile, append_log=True)): |
| 172 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create image dir for " + package) |
| 173 |
|
| 174 |
# Create list of files for tar to work with from CONTENTS file in vdb entry |
| 175 |
entries = self.parse_vdb_contents("/var/db/pkg/" + package + "/CONTENTS") |
| 176 |
if not entries: |
| 177 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping tar and symlink fixup") |
| 178 |
else: |
| 179 |
# if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot: files for " + package + ": " + str(entries)) |
| 180 |
try: |
| 181 |
tarfiles = open("/tmp/tarfilelist", "w") |
| 182 |
for entry in entries: |
| 183 |
parts = entry.split(" ") |
| 184 |
# # Hack for symlink crappiness |
| 185 |
# for symlink in symlinks: |
| 186 |
# if parts[0].startswith(symlink): |
| 187 |
# parts[0] = symlinks[symlink] + parts[0][len(symlink):] |
| 188 |
tarfiles.write(parts[0] + "\n") |
| 189 |
tarfiles.close() |
| 190 |
except: |
| 191 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create filelist for " + package) |
| 192 |
|
| 193 |
# Use tar to transfer files into IMAGE directory |
| 194 |
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'") |
| 195 |
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", logfile=self._compile_logfile, append_log=True)): |
| 196 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute tar for " + package) |
| 197 |
|
| 198 |
# Fix mode, uid, and gid of directories |
| 199 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running find " + self._chroot_dir + image_dir + " -mindepth 1 -type d 2>/dev/null | sed -e 's:^" + self._chroot_dir + image_dir + "::' | grep -v '^$'") |
| 200 |
dirlist = GLIUtility.spawn("find " + self._chroot_dir + image_dir + " -mindepth 1 -type d 2>/dev/null | sed -e 's:^" + self._chroot_dir + image_dir + "::' | grep -v '^$'", return_output=True)[1].strip().split("\n") |
| 201 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): found the following directories: " + str(dirlist)) |
| 202 |
if not dirlist or dirlist[0] == "": |
| 203 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "directory list entry for " + package + "...this shouldn't happen!") |
| 204 |
for dir in dirlist: |
| 205 |
dirstat = os.stat(dir) |
| 206 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): setting mode " + str(dirstat[0]) + " and uid/gid " + str(dirstat[4]) + "/" + str(dirstat[5]) + " for directory " + self._chroot_dir + image_dir + dir) |
| 207 |
os.chown(self._chroot_dir + image_dir + dir, dirstat[4], dirstat[5]) |
| 208 |
os.chmod(self._chroot_dir + image_dir + dir, dirstat[0]) |
| 209 |
|
| 210 |
# # More symlink crappiness hacks |
| 211 |
# for symlink in symlinks: |
| 212 |
## if GLIUtility.is_file(self._chroot_dir + image_dir + symlinks[symlink]): |
| 213 |
# if os.path.islink(self._chroot_dir + image_dir + symlink): |
| 214 |
# if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): fixing " + symlink + " symlink ickiness stuff in " + image_dir + " for " + package) |
| 215 |
# GLIUtility.spawn("rm " + self._chroot_dir + image_dir + symlink) |
| 216 |
# if not GLIUtility.exitsuccess(GLIUtility.spawn("mv " + self._chroot_dir + image_dir + symlinks[symlink] + " " + self._chroot_dir + image_dir + symlink)): |
| 217 |
# raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not fix " + symlink + " symlink ickiness for " + package) |
| 218 |
|
| 219 |
# Run pkg_setup |
| 220 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running pkg_setup for " + package) |
| 221 |
if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " FEATURES=noauto ebuild " + vdb_dir + package + "/*.ebuild setup", chroot=tmp_chroot_dir, logfile=self._compile_logfile, append_log=True)): |
| 222 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute pkg_setup for " + package) |
| 223 |
|
| 224 |
# Run pkg_preinst |
| 225 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running preinst for " + package) |
| 226 |
if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " FEATURES=noauto ebuild " + vdb_dir + package + "/*.ebuild preinst", chroot=tmp_chroot_dir, logfile=self._compile_logfile, append_log=True)): |
| 227 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute preinst for " + package) |
| 228 |
|
| 229 |
# Copy files from image_dir to chroot |
| 230 |
if not entries: |
| 231 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping copy from image dir to /") |
| 232 |
else: |
| 233 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying files from " + image_dir + " to / for " + package) |
| 234 |
# if not GLIUtility.exitsuccess(GLIUtility.spawn("cp -a " + self._chroot_dir + image_dir + "/* " + self._chroot_dir)): |
| 235 |
if not GLIUtility.exitsuccess(GLIUtility.spawn("tar -C " + self._chroot_dir + image_dir + "/ -cp . | tar -C " + self._chroot_dir + "/ -xp", logfile=self._compile_logfile, append_log=True)): |
| 236 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy files from " + image_dir + " to / for " + package) |
| 237 |
|
| 238 |
# Run pkg_postinst |
| 239 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running postinst for " + package) |
| 240 |
if not GLIUtility.exitsuccess(GLIUtility.spawn("env " + root_cmd + " PORTAGE_TMPDIR=" + portage_tmpdir + " FEATURES=noauto ebuild " + vdb_dir + package + "/*.ebuild postinst", chroot=tmp_chroot_dir, logfile=self._compile_logfile, append_log=True)): |
| 241 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute postinst for " + package) |
| 242 |
|
| 243 |
# Remove image_dir |
| 244 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): removing " + image_dir + " for " + package) |
| 245 |
if not GLIUtility.exitsuccess(GLIUtility.spawn("rm -rf " + self._chroot_dir + image_dir, logfile=self._compile_logfile, append_log=True)): |
| 246 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not remove + " + image_dir + " for " + package) |
| 247 |
|
| 248 |
# Run env-update |
| 249 |
if not use_root: |
| 250 |
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running env-update inside chroot") |
| 251 |
if not GLIUtility.exitsuccess(GLIUtility.spawn("env-update", chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)): |
| 252 |
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not run env-update for " + package) |
| 253 |
|
| 254 |
def add_pkg_to_world(self, package): |
| 255 |
if package.find("/") == -1: |
| 256 |
package = self.get_best_version_vdb_chroot(package) |
| 257 |
if not package: return False |
| 258 |
expr = re.compile('^=?(.+?/.+?)(-\d.+)?$') |
| 259 |
res = expr.match(package) |
| 260 |
if res: |
| 261 |
world_f = open(self._chroot_dir + "/var/lib/portage/world", "a") |
| 262 |
world_f.write(res.group(1) + "\n") |
| 263 |
world_f.close() |
| 264 |
|
| 265 |
def get_best_version_vdb(self, package): |
| 266 |
if package.startswith('='): |
| 267 |
package = package[1:] |
| 268 |
if GLIUtility.is_file("/var/db/pkg/" + package): |
| 269 |
return package |
| 270 |
else: |
| 271 |
return "" |
| 272 |
else: |
| 273 |
return GLIUtility.spawn("portageq best_version / " + package, return_output=True)[1].strip() |
| 274 |
|
| 275 |
def get_best_version_vdb_chroot(self, package): |
| 276 |
if package.startswith('='): |
| 277 |
package = package[1:] |
| 278 |
if GLIUtility.is_file(self._chroot_dir + "/var/db/pkg/" + package): |
| 279 |
return package |
| 280 |
else: |
| 281 |
return "" |
| 282 |
else: |
| 283 |
return GLIUtility.spawn("portageq best_version / " + package, chroot=self._chroot_dir, return_output=True)[1].strip() |
| 284 |
|
| 285 |
# def get_best_version_tree(self, package): |
| 286 |
# return portage.best(tree.match(package)) |
| 287 |
|
| 288 |
def emerge(self, packages, grp_install=False, add_to_world=True): |
| 289 |
if isinstance(packages, str): |
| 290 |
packages = packages.split() |
| 291 |
self._cc.addNotification("progress", (0, "Calculating dependencies for " + " ".join(packages))) |
| 292 |
pkglist = self.get_deps(packages, grp_install) |
| 293 |
if self._debug: self._logger.log("install_packages(): pkglist is " + str(pkglist)) |
| 294 |
for i, pkg in enumerate(pkglist): |
| 295 |
if not pkg: continue |
| 296 |
if self._debug: self._logger.log("install_packages(): processing package " + pkg) |
| 297 |
self._cc.addNotification("progress", (float(i) / len(pkglist), "Emerging " + pkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")")) |
| 298 |
if not grp_install or not self.get_best_version_vdb("=" + pkg): |
| 299 |
status = GLIUtility.spawn("emerge -1 =" + pkg, display_on_tty8=True, chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True) |
| 300 |
# status = self._emerge("=" + pkg) |
| 301 |
if not GLIUtility.exitsuccess(status): |
| 302 |
raise GLIException("EmergePackageError", "fatal", "emerge", "Could not emerge " + pkg + "!") |
| 303 |
else: |
| 304 |
# try: |
| 305 |
self.copy_pkg_to_chroot(pkg) |
| 306 |
# except: |
| 307 |
# raise GLIException("EmergePackageError", "fatal", "emerge", "Could not emerge " + pkg + "!") |
| 308 |
self._cc.addNotification("progress", (float(i+1) / len(pkglist), "Done emerging " + pkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")")) |
| 309 |
if add_to_world: |
| 310 |
for package in packages: |
| 311 |
self.add_pkg_to_world(package) |
| 312 |
|
| 313 |
|
| 314 |
def usage(progname): |
| 315 |
print """ |
| 316 |
Usage: %s [-c|--chroot-dir <chroot directory>] [-g|--grp] [-s|--stage3] [-h|--help] |
| 317 |
|
| 318 |
Options: |
| 319 |
|
| 320 |
-c|--chroot-dir Specifies the directory where your chroot is. This is |
| 321 |
"/mnt/gentoo" by default. |
| 322 |
|
| 323 |
-g|--grp Install specified packages and dependencies into chroot |
| 324 |
by using files from the LiveCD. |
| 325 |
|
| 326 |
-s|--stage3 Create a stage3 equivelant in the chroot directory by using |
| 327 |
files from the LiveCD. |
| 328 |
|
| 329 |
-k|--kernel Install kernel and modules from LiveCD into the chroot |
| 330 |
|
| 331 |
-h|--help Display this help |
| 332 |
""" % (progname) |
| 333 |
|
| 334 |
if __name__ == "__main__": |
| 335 |
chroot_dir = "/mnt/gentoo" |
| 336 |
mode = None |
| 337 |
grp_packages = [] |
| 338 |
progname = sys.argv.pop(0) |
| 339 |
while len(sys.argv): |
| 340 |
arg = sys.argv.pop(0) |
| 341 |
if arg == "-c" or arg == "--chroot-dir": |
| 342 |
chroot_dir = sys.argv.pop(0) |
| 343 |
elif arg == "-g" or arg == "--grp": |
| 344 |
mode = "grp" |
| 345 |
elif arg == "-s" or arg == "--stage3": |
| 346 |
mode = "stage3" |
| 347 |
elif arg == "-k" or arg == "--kernel": |
| 348 |
mode = "kernel" |
| 349 |
elif arg == "-h" or arg == "--help": |
| 350 |
usage(progname) |
| 351 |
sys.exit(0) |
| 352 |
elif arg[0] == "-": |
| 353 |
usage(progname) |
| 354 |
sys.exit(1) |
| 355 |
else: |
| 356 |
grp_packages.append(arg) |
| 357 |
|
| 358 |
gliportage = GLIPortage(chroot_dir, True, None, False, None, None) |
| 359 |
if mode == "stage3": |
| 360 |
if not GLIUtility.is_file("/usr/livecd/systempkgs.txt"): |
| 361 |
print "Required file /usr/livecd/systempkgs.txt does not exist!" |
| 362 |
sys.exit(1) |
| 363 |
try: |
| 364 |
syspkgs = open("/usr/livecd/systempkgs.txt", "r") |
| 365 |
systempkgs = syspkgs.readlines() |
| 366 |
syspkgs.close() |
| 367 |
except: |
| 368 |
print "Could not open /usr/livecd/systempkgs.txt!" |
| 369 |
sys.exit(1) |
| 370 |
|
| 371 |
# Pre-create /lib (and possible /lib32 and /lib64) |
| 372 |
if os.path.islink("/lib") and os.readlink("/lib") == "lib64": |
| 373 |
if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir " + chroot_dir + "/lib64 && ln -s lib64 " + chroot_dir + "/lib")): |
| 374 |
print "Could not precreate /lib64 dir and /lib -> /lib64 symlink" |
| 375 |
sys.exit(1) |
| 376 |
|
| 377 |
syspkglen = len(systempkgs) |
| 378 |
for i, pkg in enumerate(systempkgs): |
| 379 |
pkg = pkg.strip() |
| 380 |
print "Copying " + pkg + " (" + str(i+1) + "/" + str(syspkglen) + ")" |
| 381 |
gliportage.copy_pkg_to_chroot(pkg, True, ignore_missing=True) |
| 382 |
GLIUtility.spawn("cp /etc/make.conf " + chroot_dir + "/etc/make.conf") |
| 383 |
GLIUtility.spawn("ln -s `readlink /etc/make.profile` " + chroot_dir + "/etc/make.profile") |
| 384 |
GLIUtility.spawn("cp -f /etc/inittab.old " + chroot_dir + "/etc/inittab") |
| 385 |
|
| 386 |
# Nasty, nasty, nasty hack because vapier is a tool |
| 387 |
for tmpfile in ("/etc/passwd", "/etc/group", "/etc/shadow"): |
| 388 |
GLIUtility.spawn("grep -ve '^gentoo' " + tmpfile + " > " + chroot_dir + tmpfile) |
| 389 |
|
| 390 |
chrootscript = r""" |
| 391 |
#!/bin/bash |
| 392 |
|
| 393 |
source /etc/make.conf |
| 394 |
export LDPATH="/usr/lib/gcc-lib/${CHOST}/$(cd /usr/lib/gcc-lib/${CHOST} && ls -1 | head -n 1)" |
| 395 |
|
| 396 |
ldconfig $LDPATH |
| 397 |
gcc-config 1 |
| 398 |
env-update |
| 399 |
source /etc/profile |
| 400 |
modules-update |
| 401 |
[ -f /usr/bin/binutils-config ] && binutils-config 1 |
| 402 |
source /etc/profile |
| 403 |
#mount -t proc none /proc |
| 404 |
#cd /dev |
| 405 |
#/sbin/MAKEDEV generic-i386 |
| 406 |
#umount /proc |
| 407 |
[ -f /lib/udev-state/devices.tar.bz2 ] && tar -C /dev -xjf /lib/udev-state/devices.tar.bz2 |
| 408 |
""" |
| 409 |
script = open(chroot_dir + "/tmp/extrastuff.sh", "w") |
| 410 |
script.write(chrootscript) |
| 411 |
script.close() |
| 412 |
GLIUtility.spawn("chmod 755 /tmp/extrastuff.sh && /tmp/extrastuff.sh", chroot=chroot_dir) |
| 413 |
GLIUtility.spawn("rm -rf /var/tmp/portage/* /usr/portage /tmp/*", chroot=chroot_dir) |
| 414 |
print "Stage3 equivelant generation complete!" |
| 415 |
elif mode == "grp": |
| 416 |
for pkg in grp_packages: |
| 417 |
if not gliportage.get_best_version_vdb(pkg): |
| 418 |
print "Package " + pkg + " is not available for install from the LiveCD" |
| 419 |
continue |
| 420 |
pkglist = gliportage.get_deps(pkg, True) |
| 421 |
for i, tmppkg in enumerate(pkglist): |
| 422 |
print "Copying " + tmppkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")" |
| 423 |
gliportage.copy_pkg_to_chroot(tmppkg) |
| 424 |
gliportage.add_pkg_to_world(pkg) |
| 425 |
print "GRP install complete!" |
| 426 |
elif mode == "kernel": |
| 427 |
kernelpkg = gliportage.get_best_version_vdb("sys-kernel/livecd-kernel") |
| 428 |
gliportage.copy_pkg_to_chroot(kernelpkg) |
| 429 |
print "LiveCD kernel installed!" |
| 430 |
else: |
| 431 |
print "You must specify an operating mode (-g or -s)!" |
| 432 |
usage(progname) |
| 433 |
sys.exit(1) |
Parent Directory
| 
Revision Log