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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1342 - (hide annotations) (download) (as text)
Sun Mar 5 06:21:21 2006 UTC (8 years, 5 months ago) by agaffney
Original Path: trunk/src/GLIPortage.py
File MIME type: text/x-python
File size: 19390 byte(s)
make copy_pkg_to_chroot() not quite so verbose in verbose mode

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

Properties

Name Value
svn:eol-style native

  ViewVC Help
Powered by ViewVC 1.1.20