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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1790 - (hide annotations) (download) (as text)
Mon Mar 12 03:57:20 2007 UTC (7 years, 1 month ago) by agaffney
File MIME type: text/x-python
File size: 21409 byte(s)
apparently we don't need to pre-create dirs...just put stuff where portage expects it to be
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 agaffney 1762 os.mkdir(self._chroot_dir + "/var", 0755)
84 agaffney 1760 if not os.path.isdir(self._chroot_dir + "/var/cache"):
85 agaffney 1762 os.mkdir(self._chroot_dir + "/var/cache", 0755)
86 agaffney 1760 if not os.path.isdir(self._chroot_dir + "/var/cache/edb"):
87 agaffney 1762 os.mkdir(self._chroot_dir + "/var/cache/edb", 0775)
88 agaffney 1760 # chown to root:portage
89 agaffney 1761 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 agaffney 1757 return counter
96    
97 agaffney 1280 def copy_pkg_to_chroot(self, package, use_root=False, ignore_missing=False):
98 agaffney 1221 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 agaffney 1182
102 agaffney 1469 tmpdir = "/var/tmp"
103 agaffney 1790 image_dir = tmpdir + "/portage/" + package + "/image"
104 agaffney 1198 root_cmd = ""
105     tmp_chroot_dir = self._chroot_dir
106 agaffney 1469 portage_tmpdir = "/var/tmp"
107 agaffney 1270 vdb_dir = "/var/db/pkg/"
108 agaffney 1198 if use_root:
109     root_cmd = "ROOT=" + self._chroot_dir
110 agaffney 1203 tmp_chroot_dir = ""
111 agaffney 1469 portage_tmpdir = self._chroot_dir + "/var/tmp"
112 agaffney 1270 vdb_dir = self._chroot_dir + "/var/db/pkg/"
113 agaffney 1198
114 agaffney 1339 # 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 agaffney 1280 # 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 agaffney 1182 # 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 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)):
156 agaffney 1182 raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy vdb entry for " + package)
157    
158 agaffney 1757 # Update COUNTER
159 agaffney 1761 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 agaffney 1757 try:
162 agaffney 1761 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 agaffney 1757 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 agaffney 1208 # 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 agaffney 1314 if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir -p " + self._chroot_dir + image_dir, logfile=self._compile_logfile, append_log=True)):
172 agaffney 1208 raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create image dir for " + package)
173    
174 agaffney 1182 # Create list of files for tar to work with from CONTENTS file in vdb entry
175 agaffney 1221 entries = self.parse_vdb_contents("/var/db/pkg/" + package + "/CONTENTS")
176 agaffney 1208 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 agaffney 1342 # if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot: files for " + package + ": " + str(entries))
180 agaffney 1208 try:
181     tarfiles = open("/tmp/tarfilelist", "w")
182     for entry in entries:
183     parts = entry.split(" ")
184 agaffney 1222 # # Hack for symlink crappiness
185 agaffney 1221 # for symlink in symlinks:
186     # if parts[0].startswith(symlink):
187     # parts[0] = symlinks[symlink] + parts[0][len(symlink):]
188 agaffney 1208 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 agaffney 1182
193 agaffney 1208 # Use tar to transfer files into IMAGE directory
194 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'")
195 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)):
196 agaffney 1208 raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute tar for " + package)
197 agaffney 1182
198 agaffney 1338 # Fix mode, uid, and gid of directories
199 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 '^$'")
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 agaffney 1338
210 agaffney 1221 # # 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 agaffney 1182
219     # Run pkg_setup
220     if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running pkg_setup for " + package)
221 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)):
222 agaffney 1182 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 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)):
227 agaffney 1182 raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute preinst for " + package)
228    
229     # Copy files from image_dir to chroot
230 agaffney 1208 if not entries:
231 agaffney 1209 if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping copy from image dir to /")
232 agaffney 1208 else:
233     if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying files from " + image_dir + " to / for " + package)
234 agaffney 1291 # if not GLIUtility.exitsuccess(GLIUtility.spawn("cp -a " + self._chroot_dir + image_dir + "/* " + self._chroot_dir)):
235 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)):
236 agaffney 1208 raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy files from " + image_dir + " to / for " + package)
237 agaffney 1182
238     # Run pkg_postinst
239     if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running postinst for " + package)
240 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)):
241 agaffney 1182 raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute postinst for " + package)
242    
243     # Remove image_dir
244 agaffney 1208 if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): removing " + image_dir + " for " + package)
245 agaffney 1314 if not GLIUtility.exitsuccess(GLIUtility.spawn("rm -rf " + self._chroot_dir + image_dir, logfile=self._compile_logfile, append_log=True)):
246 agaffney 1182 raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not remove + " + image_dir + " for " + package)
247    
248 agaffney 1297 # 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 agaffney 1314 if not GLIUtility.exitsuccess(GLIUtility.spawn("env-update", chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)):
252 agaffney 1297 raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not run env-update for " + package)
253    
254 agaffney 1182 def add_pkg_to_world(self, package):
255     if package.find("/") == -1:
256 agaffney 1195 package = self.get_best_version_vdb_chroot(package)
257 agaffney 1182 if not package: return False
258 agaffney 1205 expr = re.compile('^=?(.+?/.+?)(-\d.+)?$')
259 agaffney 1182 res = expr.match(package)
260     if res:
261 agaffney 1767 world_f = open(self._chroot_dir + "/var/lib/portage/world", "a")
262     world_f.write(res.group(1) + "\n")
263     world_f.close()
264 agaffney 1182
265 agaffney 1185 def get_best_version_vdb(self, package):
266 agaffney 1285 if package.startswith('='):
267     package = package[1:]
268     if GLIUtility.is_file("/var/db/pkg/" + package):
269     return package
270 agaffney 1286 else:
271     return ""
272 agaffney 1285 else:
273     return GLIUtility.spawn("portageq best_version / " + package, return_output=True)[1].strip()
274 agaffney 1189
275 agaffney 1194 def get_best_version_vdb_chroot(self, package):
276 agaffney 1287 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 agaffney 1194
285 agaffney 1184 # def get_best_version_tree(self, package):
286     # return portage.best(tree.match(package))
287 agaffney 1205
288 codeman 1675 def emerge(self, packages, grp_install=False, add_to_world=True):
289 agaffney 1205 if isinstance(packages, str):
290     packages = packages.split()
291 agaffney 1223 self._cc.addNotification("progress", (0, "Calculating dependencies for " + " ".join(packages)))
292 agaffney 1700 pkglist = self.get_deps(packages, grp_install)
293 agaffney 1205 if self._debug: self._logger.log("install_packages(): pkglist is " + str(pkglist))
294     for i, pkg in enumerate(pkglist):
295 agaffney 1305 if not pkg: continue
296 agaffney 1205 if self._debug: self._logger.log("install_packages(): processing package " + pkg)
297 agaffney 1208 self._cc.addNotification("progress", (float(i) / len(pkglist), "Emerging " + pkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")"))
298 agaffney 1674 if not grp_install or not self.get_best_version_vdb("=" + pkg):
299 agaffney 1205 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 agaffney 1208 self._cc.addNotification("progress", (float(i+1) / len(pkglist), "Done emerging " + pkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")"))
309 agaffney 1205 if add_to_world:
310     for package in packages:
311     self.add_pkg_to_world(package)
312 agaffney 1306
313    
314 agaffney 1311 def usage(progname):
315 agaffney 1306 print """
316 agaffney 1311 Usage: %s [-c|--chroot-dir <chroot directory>] [-g|--grp] [-s|--stage3] [-h|--help]
317 agaffney 1306
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 agaffney 1527 -k|--kernel Install kernel and modules from LiveCD into the chroot
330    
331 agaffney 1306 -h|--help Display this help
332 agaffney 1311 """ % (progname)
333 agaffney 1306
334     if __name__ == "__main__":
335     chroot_dir = "/mnt/gentoo"
336     mode = None
337     grp_packages = []
338 agaffney 1311 progname = sys.argv.pop(0)
339 agaffney 1307 while len(sys.argv):
340 agaffney 1306 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 agaffney 1526 elif arg == "-k" or arg == "--kernel":
348     mode = "kernel"
349 agaffney 1306 elif arg == "-h" or arg == "--help":
350 agaffney 1311 usage(progname)
351 agaffney 1306 sys.exit(0)
352     elif arg[0] == "-":
353 agaffney 1311 usage(progname)
354 agaffney 1306 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 agaffney 1310 print "Copying " + pkg + " (" + str(i+1) + "/" + str(syspkglen) + ")"
381 agaffney 1306 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 agaffney 1311 continue
420 agaffney 1700 pkglist = gliportage.get_deps(pkg, True)
421 agaffney 1311 for i, tmppkg in enumerate(pkglist):
422     print "Copying " + tmppkg + " (" + str(i+1) + "/" + str(len(pkglist)) + ")"
423 agaffney 1306 gliportage.copy_pkg_to_chroot(tmppkg)
424     gliportage.add_pkg_to_world(pkg)
425     print "GRP install complete!"
426 agaffney 1526 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 agaffney 1306 else:
431     print "You must specify an operating mode (-g or -s)!"
432 agaffney 1311 usage(progname)
433 agaffney 1306 sys.exit(1)

Properties

Name Value
svn:eol-style native

  ViewVC Help
Powered by ViewVC 1.1.20