/[gli]/branches/overhaul/src/GLIPortage.py
Gentoo

Contents of /branches/overhaul/src/GLIPortage.py

Parent Directory Parent Directory | Revision Log Revision Log


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

Properties

Name Value
svn:eol-style native

  ViewVC Help
Powered by ViewVC 1.1.20