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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

Properties

Name Value
svn:eol-style native

  ViewVC Help
Powered by ViewVC 1.1.20