def _partition_resize_step(self, parted_disk, device, oldparts, newparts):
for oldpart in oldparts:
tmppart_old = oldparts[oldpart]
devnode = tmppart_old['devnode']
newminor = self._find_existing_in_new(oldpart, newparts)
if not newminor or not newparts[newminor]['resized']:
continue
tmppart_new = newparts[newminor]
type = tmppart_new['type']
start = tmppart_new['start']
end = start + (long(tmppart['mb']) * MEGABYTE / 512) - 1
total_sectors = end - start + 1
total_bytes = long(total_sectors) * 512
# Make sure calculated end sector doesn't overlap start sector of next partition
nextminor = self._find_next_partition(newminor, newparts)
if nextminor:
if newparts[nextminor]['start'] and end >= newparts[nextminor]['start']:
self._logger.log(" End sector for growing partition overlaps with start of next partition...fixing")
end = newparts[nextminor]['start'] - 1
# sleep a bit first
time.sleep(3)
# now sleep until it exists
while not GLIUtility.is_file(device + str(minor)):
self._logger.log("Waiting for device node " + devnode + " to exist before resizing")
time.sleep(1)
# one bit of extra sleep is needed, as there is a blip still
time.sleep(3)
if type in ("ext2", "ext3"):
ret = GLIUtility.spawn("resize2fs " + devnode + " " + str(total_sectors) + "s", logfile=self._compile_logfile, append_log=True)
if not GLIUtility.exitsuccess(ret): # Resize error
raise GLIException("PartitionResizeError", 'fatal', 'partition', "could not resize ext2/3 filesystem on " + devnode)
elif type == "ntfs":
ret = GLIUtility.spawn("yes | ntfsresize -v --size " + str(total_bytes) + " " + devnode, logfile=self._compile_logfile, append_log=True)
if not GLIUtility.exitsuccess(ret): # Resize error
raise GLIException("PartitionResizeError", 'fatal', 'partition', "could not resize NTFS filesystem on " + devnode)
elif type in ("linux-swap", "fat32", "fat16"):
parted_fs = parted_disk.get_partition(part).geom.file_system_open()
resize_constraint = parted_fs.get_resize_constraint()
if total_sectors < resize_constraint.min_size or start != resize_constraint.start_range.start:
raise GLIException("PartitionError", 'fatal', 'partition', "New size specified for " + device + str(minor) + " is not within allowed boundaries (blame parted)")
new_geom = resize_constraint.start_range.duplicate()
new_geom.set_start(start)
new_geom.set_end(end)
try:
parted_fs.resize(new_geom)
except:
raise GLIException("PartitionResizeError", 'fatal', 'partition', "could not resize " + device + str(minor))
self._logger.log(" Deleting old minor " + str(oldpart) + " to be recreated in 3rd pass")
self._delete_partition(parted_disk, oldpart)
parted_disk.delete_all()
parted_disk.commit()
def _partition_resize_step(self, parted_disk, device, oldparts, newparts):
for oldpart in oldparts:
tmppart_old = oldparts[oldpart]
devnode = tmppart_old['devnode']
newminor = self._find_existing_in_new(oldpart, newparts)
if not newminor or not newparts[newminor]['resized']:
continue
tmppart_new = newparts[newminor]
type = tmppart_new['type']
start = tmppart_new['start']
end = start + (long(tmppart['mb']) * MEGABYTE / 512) - 1
total_sectors = end - start + 1
total_bytes = long(total_sectors) * 512
# Make sure calculated end sector doesn't overlap start sector of next partition
nextminor = self._find_next_partition(newminor, newparts)
if nextminor:
if newparts[nextminor]['start'] and end >= newparts[nextminor]['start']:
self._logger.log(" End sector for growing partition overlaps with start of next partition...fixing")
end = newparts[nextminor]['start'] - 1
# sleep a bit first
time.sleep(3)
# now sleep until it exists
while not GLIUtility.is_file(device + str(minor)):
self._logger.log("Waiting for device node " + devnode + " to exist before resizing")
time.sleep(1)
# one bit of extra sleep is needed, as there is a blip still
time.sleep(3)
if type in ("ext2", "ext3"):
ret = GLIUtility.spawn("resize2fs " + devnode + " " + str(total_sectors) + "s", logfile=self._compile_logfile, append_log=True)
if not GLIUtility.exitsuccess(ret): # Resize error
raise GLIException("PartitionResizeError", 'fatal', 'partition', "could not resize ext2/3 filesystem on " + devnode)
elif type == "ntfs":
ret = GLIUtility.spawn("yes | ntfsresize -v --size " + str(total_bytes) + " " + devnode, logfile=self._compile_logfile, append_log=True)
if not GLIUtility.exitsuccess(ret): # Resize error
raise GLIException("PartitionResizeError", 'fatal', 'partition', "could not resize NTFS filesystem on " + devnode)
elif type in ("linux-swap", "fat32", "fat16"):
parted_fs = parted_disk.get_partition(part).geom.file_system_open()
resize_constraint = parted_fs.get_resize_constraint()
if total_sectors < resize_constraint.min_size or start != resize_constraint.start_range.start:
raise GLIException("PartitionError", 'fatal', 'partition', "New size specified for " + device + str(minor) + " is not within allowed boundaries (blame parted)")
new_geom = resize_constraint.start_range.duplicate()
new_geom.set_start(start)
new_geom.set_end(end)
try:
parted_fs.resize(new_geom)
except:
raise GLIException("PartitionResizeError", 'fatal', 'partition', "could not resize " + device + str(minor))
self._logger.log(" Deleting old minor " + str(oldpart) + " to be recreated in 3rd pass")
self._delete_partition(parted_disk, oldpart)
parted_disk.delete_all()
parted_disk.commit()
def _partition_format_step(self, parted_disk, device, newparts):
for part in newparts:
newpart = newparts[part]
devnode = newpart['devnode']
# This little hack is necessary because parted sucks goat nuts
if newparts.get_disklabel() == "mac" and newpart['type'] == "free":
self._delete_partition(parted_disk, newpart)
continue
if newpart['format'] and newpart['type'] not in ('extended', 'free'):
# devnode = device + str(int(part))
if self._debug: self._logger.log("_partition_format_step(): devnode is %s in formatting code" % devnode)
# if you need a special command and
# some base options, place it here.
format_cmds = { 'linux-swap': "mkswap", 'fat16': "mkfs.vfat -F 16", 'fat32': "mkfs.vfat -F 32",
'ntfs': "mkntfs", 'xfs': "mkfs.xfs -f", 'jfs': "mkfs.jfs -f",
'reiserfs': "mkfs.reiserfs -f", 'ext2': "mkfs.ext2", 'ext3': "mkfs.ext3"
}
if newpart['type'] in format_cmds:
cmdname = format_cmds[newpart['type']]
else: # this should catch everything else
raise GLIException("PartitionFormatError", 'fatal', '_partition_format_step', "Unknown partition type " + newpart['type'])
# sleep a bit first
time.sleep(1)
for tries in range(10):
cmd = "%s %s %s" % (cmdname, newpart['mkfsopts'], devnode)
self._logger.log(" Formatting partition %s as %s with: %s" % (str(part),newpart['type'],cmd))
ret = GLIUtility.spawn(cmd, logfile=self._compile_logfile, append_log=True)
if not GLIUtility.exitsuccess(ret):
self._logger.log("Try %d failed formatting partition %s...waiting 5 seconds" % (tries+1, devnode))
time.sleep(5)
else:
break
else:
raise GLIException("PartitionFormatError", 'fatal', '_partition_format_step', "Could not create %s filesystem on %s" % (newpart['type'], devnode))
def _partition_format_step(self, parted_disk, device, newparts):
for part in newparts:
newpart = newparts[part]
devnode = newpart['devnode']
# This little hack is necessary because parted sucks goat nuts
if newparts.get_disklabel() == "mac" and newpart['type'] == "free":
self._delete_partition(parted_disk, newpart)
continue
if newpart['format'] and newpart['type'] not in ('extended', 'free'):
# devnode = device + str(int(part))
if self._debug: self._logger.log("_partition_format_step(): devnode is %s in formatting code" % devnode)
# if you need a special command and
# some base options, place it here.
format_cmds = { 'linux-swap': "mkswap", 'fat16': "mkfs.vfat -F 16", 'fat32': "mkfs.vfat -F 32",
'ntfs': "mkntfs", 'xfs': "mkfs.xfs -f", 'jfs': "mkfs.jfs -f",
'reiserfs': "mkfs.reiserfs -f", 'ext2': "mkfs.ext2", 'ext3': "mkfs.ext3"
}
if newpart['type'] in format_cmds:
cmdname = format_cmds[newpart['type']]
else: # this should catch everything else
raise GLIException("PartitionFormatError", 'fatal', '_partition_format_step', "Unknown partition type " + newpart['type'])
# sleep a bit first
time.sleep(1)
for tries in range(10):
cmd = "%s %s %s" % (cmdname, newpart['mkfsopts'], devnode)
self._logger.log(" Formatting partition %s as %s with: %s" % (str(part),newpart['type'],cmd))
ret = GLIUtility.spawn(cmd, logfile=self._compile_logfile, append_log=True)
if not GLIUtility.exitsuccess(ret):
self._logger.log("Try %d failed formatting partition %s...waiting 5 seconds" % (tries+1, devnode))
time.sleep(5)
else:
break
else:
raise GLIException("PartitionFormatError", 'fatal', '_partition_format_step', "Could not create %s filesystem on %s" % (newpart['type'], devnode))
def start_portmap(self):
if self._configuration.get_verbose(): self._logger.log("DEBUG: beginning of start_portmap()")
status = GLIUtility.spawn('/etc/init.d/portmap start') #, display_on_tty8=True)
if not GLIUtility.exitsuccess(status):
self._logger.log("ERROR! : Could not start the portmap service!")
# raise GLIException("PortmapError", 'warning', 'start_portmap', "Could not start the portmap service!")
else:
self._logger.log("Portmap started.")
def enable_ssh(self):
if self._configuration.get_verbose(): self._logger.log("DEBUG: beginning of enable_ssh()")
if self._configuration.get_enable_ssh():
status = GLIUtility.spawn("/etc/init.d/sshd start")
if not GLIUtility.exitsuccess(status):
self._logger.log("ERROR! : Could not start the SSH daemon!")
# raise GLIException("SSHError", 'warning','enable_ssh',"Could not start SSH daemon!")
else:
self._logger.log("SSH Started.")
def start_portmap(self):
if self._configuration.get_verbose():
self._logger.log("DEBUG: beginning of start_portmap()")
status = GLIUtility.spawn(
'/etc/init.d/portmap start') #, display_on_tty8=True)
if not GLIUtility.exitsuccess(status):
self._logger.log("ERROR! : Could not start the portmap service!")
# raise GLIException("PortmapError", 'warning', 'start_portmap', "Could not start the portmap service!")
else:
self._logger.log("Portmap started.")
def enable_ssh(self):
if self._configuration.get_verbose():
self._logger.log("DEBUG: beginning of enable_ssh()")
if self._configuration.get_enable_ssh():
status = GLIUtility.spawn("/etc/init.d/sshd start")
if not GLIUtility.exitsuccess(status):
self._logger.log("ERROR! : Could not start the SSH daemon!")
# raise GLIException("SSHError", 'warning','enable_ssh',"Could not start SSH daemon!")
else:
self._logger.log("SSH Started.")
def set_root_passwd(self):
self._logger.log("Setting root password.")
if self._configuration.get_root_passwd() != "":
# The password specified in the configuration is encrypted.
status = GLIUtility.spawn("echo 'root:" + self._configuration.get_root_passwd() + "' | chpasswd -e")
if not GLIUtility.exitsuccess(status):
self._logger.log("ERROR! : Could not set the root password on the livecd environment!")
# raise GLIException("PasswordError", 'warning', 'set_root_passwd', "Could not set the root password!")
else:
self._logger.log("Livecd root password set.")
def set_root_passwd(self):
self._logger.log("Setting root password.")
if self._configuration.get_root_passwd() != "":
# The password specified in the configuration is encrypted.
status = GLIUtility.spawn("echo 'root:" +
self._configuration.get_root_passwd() +
"' | chpasswd -e")
if not GLIUtility.exitsuccess(status):
self._logger.log(
"ERROR! : Could not set the root password on the livecd environment!"
)
# raise GLIException("PasswordError", 'warning', 'set_root_passwd', "Could not set the root password!")
else:
self._logger.log("Livecd root password set.")
def load_kernel_modules(self):
if self._configuration.get_verbose(): self._logger.log("DEBUG: beginning of load_kernel_modules()")
modules = self._configuration.get_kernel_modules()
if self._configuration.get_verbose(): self._logger.log("DEBUG: load_kernel_modules(): modules are " + str(modules))
for module in modules:
try:
if self._configuration.get_verbose(): self._logger.log("DEBUG: load_kernel_modules(): trying to load module " + module)
ret = GLIUtility.spawn('modprobe ' + module)
if not GLIUtility.exitsuccess(ret):
self._logger.log("ERROR! : Could not load module: "+module)
# raise GLIException("KernelModuleError", 'warning', 'load_kernel_modules', 'Could not load module: ' + module)
else:
self._logger.log('kernel module: ' + module + ' loaded.')
except KernelModuleError, error:
self.output(error)
self._logger.log(error.get_error_level() + '! ' + error.get_error_msg())
def _setup_grub(self):
#-------------------------------------------------------------
#OK, now that the file is built. Install grub.
#cp /proc/mounts /etc/mtab
#grub-install --root-directory=/boot /dev/hda
#shutil.copy("/proc/mounts",root +"/etc/mtab")
self._gather_grub_drive_info()
grubinstallstring = "echo -en 'root ("+self.grub_boot_drive + "," + self.grub_boot_minor + ")\n"
if not self._install_profile.get_boot_loader_mbr():
grubinstallstring +="setup ("+self.grub_boot_drive + "," + self.grub_boot_minor + ")\n"
else:
grubinstallstring +="setup ("+self.grub_mbr_drive+")\n"
grubinstallstring += "quit\n' | "+self._chroot_dir+"/sbin/grub --batch --no-floppy"
if self._debug: self._logger.log("DEBUG: _configure_grub(): Grub install string: " + grubinstallstring)
exitstatus = GLIUtility.spawn(grubinstallstring, logfile=self._compile_logfile, append_log=True)
if not GLIUtility.exitsuccess(exitstatus):
raise GLIException("GrubInstallError", 'fatal', '_setup_grub', "Could not install grub!")
self._logger.log("Bootloader: grub has been installed!")
def _setup_grub(self):
#-------------------------------------------------------------
#OK, now that the file is built. Install grub.
#cp /proc/mounts /etc/mtab
#grub-install --root-directory=/boot /dev/hda
#shutil.copy("/proc/mounts",root +"/etc/mtab")
self._gather_grub_drive_info()
grubinstallstring = "echo -en 'root ("+self.grub_boot_drive + "," + self.grub_boot_minor + ")\n"
if not self._install_profile.get_boot_loader_mbr():
grubinstallstring +="setup ("+self.grub_boot_drive + "," + self.grub_boot_minor + ")\n"
else:
grubinstallstring +="setup ("+self.grub_mbr_drive+")\n"
grubinstallstring += "quit\n' | "+self._chroot_dir+"/sbin/grub --batch --no-floppy"
if self._debug: self._logger.log("DEBUG: _configure_grub(): Grub install string: " + grubinstallstring)
exitstatus = GLIUtility.spawn(grubinstallstring, logfile=self._compile_logfile, append_log=True)
if not GLIUtility.exitsuccess(exitstatus):
raise GLIException("GrubInstallError", 'fatal', '_setup_grub', "Could not install grub!")
self._logger.log("Bootloader: grub has been installed!")
def load_kernel_modules(self):
if self._configuration.get_verbose():
self._logger.log("DEBUG: beginning of load_kernel_modules()")
modules = self._configuration.get_kernel_modules()
if self._configuration.get_verbose():
self._logger.log("DEBUG: load_kernel_modules(): modules are " +
str(modules))
for module in modules:
try:
if self._configuration.get_verbose():
self._logger.log(
"DEBUG: load_kernel_modules(): trying to load module "
+ module)
ret = GLIUtility.spawn('modprobe ' + module)
if not GLIUtility.exitsuccess(ret):
self._logger.log("ERROR! : Could not load module: " +
module)
# raise GLIException("KernelModuleError", 'warning', 'load_kernel_modules', 'Could not load module: ' + module)
else:
self._logger.log('kernel module: ' + module + ' loaded.')
except KernelModuleError, error:
self.output(error)
self._logger.log(error.get_error_level() + '! ' +
error.get_error_msg())
def configure_networking(self):
if self._configuration.get_verbose():
self._logger.log("DEBUG: beginning of configure_networking()")
# Do networking setup right here.
if self._configuration.get_network_type() != None:
type = self._configuration.get_network_type()
if type == "null" or type == "none":
# don't do anything, it's not our problem if the user specifies this.
return
elif type == "dhcp":
if self._configuration.get_verbose():
self._logger.log(
"DEBUG: configure_networking(): DHCP selected")
# Run dhcpcd.
try:
interface = self._configuration.get_network_interface()
dhcp_options = self._configuration.get_network_dhcp_options(
)
except:
self._logger.log(
"No interface found.. defaulting to eth0.")
interface = "eth0"
dhcp_options = ""
if interface and not dhcp_options:
if self._configuration.get_verbose():
self._logger.log(
"DEBUG: configure_networking(): running '/sbin/dhcpcd -n "
+ interface + "'")
status = GLIUtility.spawn("/sbin/dhcpcd -t 15 -n " +
interface)
elif interface and dhcp_options:
if self._configuration.get_verbose():
self._logger.log(
"DEBUG: configure_networking(): running '/sbin/dhcpcd "
+ dhcp_options + " " + interface + "'")
status = GLIUtility.spawn("/sbin/dhcpcd -t 15 " +
dhcp_options + " " + interface)
else:
if self._configuration.get_verbose():
self._logger.log(
"DEBUG: configure_networking(): running '/sbin/dhcpcd -n'"
)
status = GLIUtility.spawn("/sbin/dhcpcd -t 15 -n")
if self._configuration.get_verbose():
self._logger.log(
"DEBUG: configure_networking(): call to /sbin/dhcpcd complete"
)
if not GLIUtility.exitsuccess(status):
raise GLIException(
"DHCPError", 'fatal', 'configure_networking',
"Failed to get a dhcp address for " + interface + ".")
elif type == "manual" and self._configuration.get_interactive():
# Drop to bash shell and let them configure it themselves
print "Please configure & test your network device."
GLIUtility.spawn_bash()
elif type == "manual" and not self._interactive.get_interactive():
print "You cannot manually configure the network in non-interactive mode!"
print "Please fix either the network settings or the interactive mode!"
sys.exit(1)
elif type == "static":
if self._configuration.get_verbose():
self._logger.log(
"DEBUG: configure_networking(): setting static IP")
# Configure the network from the settings they gave.
net_interface = self._configuration.get_network_interface()
net_ip = self._configuration.get_network_ip()
net_broadcast = self._configuration.get_network_broadcast()
net_netmask = self._configuration.get_network_netmask()
if not GLIUtility.set_ip(net_interface, net_ip, net_broadcast,
net_netmask):
raise GLIException("SetIPError", 'fatal',
'configure_networking',
"Could not set the IP address!")
route = self._configuration.get_network_gateway()
if not GLIUtility.set_default_route(route):
raise GLIException("DefaultRouteError", 'fatal',
'configure_networking',
"Could not set the default route!")
dns_servers = self._configuration.get_dns_servers()
if dns_servers:
try:
resolv_conf = open("/etc/resolv.conf", "w")
for dns_server in dns_servers:
resolv_conf.write("nameserver " + dns_server +
"\n")
resolv_conf.close()
except:
raise GLIException("DNSServerError", 'fatal',
'configure_networking',
"Could not set the DNS servers!")
if self._configuration.get_verbose():
self._logger.log(
"DEBUG: configure_networking(): done setting static IP"
)
def copy_pkg_to_chroot(self, package, use_root=False, ignore_missing=False):
symlinks = { '/bin': '/mnt/livecd/bin/', '/boot': '/mnt/livecd/boot/', '/lib': '/mnt/livecd/lib/',
'/opt': '/mnt/livecd/opt/', '/sbin': '/mnt/livecd/sbin/', '/usr': '******',
'/etc/gconf': '/usr/livecd/gconf/' }
tmpdir = "/var/tmp/portage"
image_dir = tmpdir + "/" + package.split("/")[1] + "/image"
root_cmd = ""
tmp_chroot_dir = self._chroot_dir
portage_tmpdir = "/var/tmp/portage"
vdb_dir = "/var/db/pkg/"
if use_root:
root_cmd = "ROOT=" + self._chroot_dir
tmp_chroot_dir = ""
portage_tmpdir = self._chroot_dir + "/var/tmp/portage"
vdb_dir = self._chroot_dir + "/var/db/pkg/"
# Create /tmp, /var/tmp, and /var/lib/portage with proper permissions
oldumask = os.umask(0)
if not os.path.exists(self._chroot_dir + "/tmp"):
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): /tmp doesn't exist in chroot...creating with proper permissions")
try:
os.mkdir(self._chroot_dir + "/tmp", 01777)
except:
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Failed to create /tmp in chroot")
if not os.path.exists(self._chroot_dir + "/var/tmp"):
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): /var/tmp doesn't exist in chroot...creating with proper permissions")
try:
os.mkdir(self._chroot_dir + "/var", 0755)
except:
pass
try:
os.mkdir(self._chroot_dir + "/var/tmp", 01777)
except:
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Failed to create /var/tmp in chroot")
if not os.path.exists(self._chroot_dir + "/var/lib/portage"):
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): /var/lib/portage doesn't exist in chroot...creating with proper permissions")
try:
os.mkdir(self._chroot_dir + "/var/lib", 0755)
except:
pass
try:
os.mkdir(self._chroot_dir + "/var/lib/portage", 02750)
except:
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Failed to create /var/lib/portage in chroot")
os.umask(oldumask)
# Check to see if package is actually in vdb
if not GLIUtility.is_file("/var/db/pkg/" + package):
if ignore_missing:
if self._debug:
self._logger.log("DEBUG: copy_pkg_to_chroot(): package " + package + " does not have a vdb entry but ignore_missing=True...ignoring error")
return
else:
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "There is no vdb entry for " + package)
# Copy the vdb entry for the package from the LiveCD to the chroot
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying vdb entry for " + package)
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)):
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy vdb entry for " + package)
# Create the image dir in the chroot
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running 'mkdir -p " + self._chroot_dir + image_dir + "'")
if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir -p " + self._chroot_dir + image_dir, logfile=self._compile_logfile, append_log=True)):
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create image dir for " + package)
# Create list of files for tar to work with from CONTENTS file in vdb entry
entries = self.parse_vdb_contents("/var/db/pkg/" + package + "/CONTENTS")
if not entries:
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping tar and symlink fixup")
else:
# if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot: files for " + package + ": " + str(entries))
try:
tarfiles = open("/tmp/tarfilelist", "w")
for entry in entries:
parts = entry.split(" ")
# # Hack for symlink crappiness
# for symlink in symlinks:
# if parts[0].startswith(symlink):
# parts[0] = symlinks[symlink] + parts[0][len(symlink):]
tarfiles.write(parts[0] + "\n")
tarfiles.close()
except:
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not create filelist for " + package)
# Use tar to transfer files into IMAGE directory
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'")
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)):
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute tar for " + package)
# Fix mode, uid, and gid of directories
# 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 '^$'")
# 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")
# if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): found the following directories: " + str(dirlist))
# if not dirlist or dirlist[0] == "":
# raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "directory list entry for " + package + "...this shouldn't happen!")
# for dir in dirlist:
# dirstat = os.stat(dir)
# 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)
# os.chown(self._chroot_dir + image_dir + dir, dirstat[4], dirstat[5])
# os.chmod(self._chroot_dir + image_dir + dir, dirstat[0])
# # More symlink crappiness hacks
# for symlink in symlinks:
## if GLIUtility.is_file(self._chroot_dir + image_dir + symlinks[symlink]):
# if os.path.islink(self._chroot_dir + image_dir + symlink):
# if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): fixing " + symlink + " symlink ickiness stuff in " + image_dir + " for " + package)
# GLIUtility.spawn("rm " + self._chroot_dir + image_dir + symlink)
# if not GLIUtility.exitsuccess(GLIUtility.spawn("mv " + self._chroot_dir + image_dir + symlinks[symlink] + " " + self._chroot_dir + image_dir + symlink)):
# raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not fix " + symlink + " symlink ickiness for " + package)
# Run pkg_setup
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running pkg_setup for " + package)
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)):
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute pkg_setup for " + package)
# Run pkg_preinst
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running preinst for " + package)
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)):
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute preinst for " + package)
# Copy files from image_dir to chroot
if not entries:
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): no files for " + package + "...skipping copy from image dir to /")
else:
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): copying files from " + image_dir + " to / for " + package)
# if not GLIUtility.exitsuccess(GLIUtility.spawn("cp -a " + self._chroot_dir + image_dir + "/* " + self._chroot_dir)):
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)):
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not copy files from " + image_dir + " to / for " + package)
# Run pkg_postinst
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running postinst for " + package)
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)):
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not execute postinst for " + package)
# Remove image_dir
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): removing " + image_dir + " for " + package)
if not GLIUtility.exitsuccess(GLIUtility.spawn("rm -rf " + self._chroot_dir + image_dir, logfile=self._compile_logfile, append_log=True)):
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not remove + " + image_dir + " for " + package)
# Run env-update
if not use_root:
if self._debug: self._logger.log("DEBUG: copy_pkg_to_chroot(): running env-update inside chroot")
if not GLIUtility.exitsuccess(GLIUtility.spawn("env-update", chroot=self._chroot_dir, logfile=self._compile_logfile, append_log=True)):
raise GLIException("CopyPackageToChrootError", 'fatal', 'copy_pkg_to_chroot', "Could not run env-update for " + package)
gliportage = GLIPortage(chroot_dir, True, None, False, None, None)
if mode == "stage3":
if not GLIUtility.is_file("/usr/livecd/systempkgs.txt"):
print "Required file /usr/livecd/systempkgs.txt does not exist!"
sys.exit(1)
try:
syspkgs = open("/usr/livecd/systempkgs.txt", "r")
systempkgs = syspkgs.readlines()
syspkgs.close()
except:
print "Could not open /usr/livecd/systempkgs.txt!"
sys.exit(1)
# Pre-create /lib (and possible /lib32 and /lib64)
if os.path.islink("/lib") and os.readlink("/lib") == "lib64":
if not GLIUtility.exitsuccess(GLIUtility.spawn("mkdir " + chroot_dir + "/lib64 && ln -s lib64 " + chroot_dir + "/lib")):
print "Could not precreate /lib64 dir and /lib -> /lib64 symlink"
sys.exit(1)
syspkglen = len(systempkgs)
for i, pkg in enumerate(systempkgs):
pkg = pkg.strip()
print "Copying " + pkg + " (" + str(i+1) + "/" + str(syspkglen) + ")"
gliportage.copy_pkg_to_chroot(pkg, True, ignore_missing=True)
GLIUtility.spawn("cp /etc/make.conf " + chroot_dir + "/etc/make.conf")
GLIUtility.spawn("ln -s `readlink /etc/make.profile` " + chroot_dir + "/etc/make.profile")
GLIUtility.spawn("cp -f /etc/inittab.old " + chroot_dir + "/etc/inittab")
# Nasty, nasty, nasty hack because vapier is a tool
for tmpfile in ("/etc/passwd", "/etc/group", "/etc/shadow"):
GLIUtility.spawn("grep -ve '^gentoo' " + tmpfile + " > " + chroot_dir + tmpfile)
def _configure_grub(self):
self.build_mode = self._install_profile.get_kernel_build_method()
self._gather_grub_drive_info()
root = self._chroot_dir
exitstatus2, kernel_names = GLIUtility.spawn("ls -1 --color=no " + root + "/boot/pentoo", return_output=True)
self._logger.log("Output of Kernel Names:\n"+kernel_names)
if not GLIUtility.exitsuccess(exitstatus2):
raise GLIException("BootloaderError", 'fatal', '_configure_grub', "Error listing the kernels in /boot")
if self.build_mode == "genkernel" or self._install_profile.get_kernel_source_pkg() == "livecd-kernel":
exitstatus3, initrd_names = GLIUtility.spawn("ls -1 --color=no " + root + "/boot/pentoo.igz", return_output=True)
self._logger.log("Output of Initrd Names:\n"+initrd_names)
if not GLIUtility.exitsuccess(exitstatus3):
raise GLIException("BootloaderError", 'fatal', '_configure_grub', "Error listing the initrds")
self._logger.log("Bootloader: the three information gathering commands have been run")
if not kernel_names[0]:
raise GLIException("BootloaderError", 'fatal', '_configure_grub',"Error: We have no kernel in /boot to put in the grub.conf file!")
#-------------------------------------------------------------
#OK, now that we have all the info, let's build that grub.conf
newgrubconf = ""
newgrubconf += "default 0\ntimeout 30\n"
if self.foundboot: #we have a /boot
newgrubconf += "splashimage=(" + self.grub_boot_drive + "," + self.grub_boot_minor + ")/grub/splash.xpm.gz\n"
else: #we have / and /boot needs to be included
newgrubconf += "splashimage=(" + self.grub_boot_drive + "," + self.grub_boot_minor + ")/boot/grub/splash.xpm.gz\n"
if self._install_profile.get_bootloader_kernel_args():
bootloader_kernel_args = self._install_profile.get_bootloader_kernel_args()
else: bootloader_kernel_args = ""
kernel_names = map(string.strip, kernel_names.strip().split("\n"))
initrd_names = map(string.strip, initrd_names.strip().split("\n"))
grub_kernel_name = kernel_names[-1].split(root)[-1]
if initrd_names: grub_initrd_name = initrd_names[-1].split(root)[-1]
# for i in range(len(kernel_names)):
# grub_kernel_name = kernel_names[i].split(root)[-1]
# for i in range(len(initrd_names)): #this should be okay if blank.
# grub_initrd_name = initrd_names[i].split(root)[-1]
#i think this means take the last one it finds.. i.e. the newest.
newgrubconf += "title=Gentoo Linux\n"
newgrubconf += "root (" + self.grub_boot_drive + "," + self.grub_boot_minor + ")\n"
if self.build_mode != "genkernel" and self._install_profile.get_kernel_source_pkg() != "livecd-kernel": #using CUSTOM kernel
if self.foundboot:
newgrubconf += "kernel " + grub_kernel_name[5:] + " root="+self.root_device+self.root_minor+"\n"
else:
newgrubconf += "kernel /boot"+ grub_kernel_name[5:] + " root="+self.root_device+self.root_minor+"\n"
else: #using genkernel so it has an initrd.
if self.foundboot:
newgrubconf += "kernel " + grub_kernel_name[5:] + " root=/dev/ram0 init=/linuxrc ramdisk=8192 real_root="
newgrubconf += self.root_device + self.root_minor + " " + bootloader_kernel_args + "\n"
newgrubconf += "initrd " + grub_initrd_name[5:] + "\n"
else:
newgrubconf += "kernel /boot" + grub_kernel_name[5:] + " root=/dev/ram0 init=/linuxrc ramdisk=8192 real_root="
newgrubconf += self.root_device + self.root_minor + " " + bootloader_kernel_args + "\n"
newgrubconf += "initrd /boot" + grub_initrd_name[5:] + "\n"
newgrubconf = self._grub_add_windows(newgrubconf)
#now make the grub.conf file
file_name = root + "/boot/grub/grub.conf"
try:
shutil.move(file_name, file_name + ".OLDdefault")
except:
pass
f = open(file_name, 'w')
f.writelines(newgrubconf)
f.close()
self._logger.log("Grub installed and configured. Contents of grub.conf:\n"+newgrubconf)
self._logger.log("Grub has not yet been run. If a normal install, it will now be run.")
def configure_networking(self):
if self._configuration.get_verbose(): self._logger.log("DEBUG: beginning of configure_networking()")
# Do networking setup right here.
if self._configuration.get_network_type() != None:
type = self._configuration.get_network_type()
if type == "null" or type == "none":
# don't do anything, it's not our problem if the user specifies this.
return
elif type == "dhcp":
if self._configuration.get_verbose(): self._logger.log("DEBUG: configure_networking(): DHCP selected")
# Run dhcpcd.
try:
interface = self._configuration.get_network_interface()
dhcp_options = self._configuration.get_network_dhcp_options()
except:
self._logger.log("No interface found.. defaulting to eth0.")
interface = "eth0"
dhcp_options = ""
if interface and not dhcp_options:
if self._configuration.get_verbose(): self._logger.log("DEBUG: configure_networking(): running '/sbin/dhcpcd -n " + interface + "'")
status = GLIUtility.spawn("/sbin/dhcpcd -t 15 -n " + interface)
elif interface and dhcp_options:
if self._configuration.get_verbose(): self._logger.log("DEBUG: configure_networking(): running '/sbin/dhcpcd " + dhcp_options + " " + interface + "'")
status = GLIUtility.spawn("/sbin/dhcpcd -t 15 " + dhcp_options + " " + interface)
else:
if self._configuration.get_verbose(): self._logger.log("DEBUG: configure_networking(): running '/sbin/dhcpcd -n'")
status = GLIUtility.spawn("/sbin/dhcpcd -t 15 -n")
if self._configuration.get_verbose(): self._logger.log("DEBUG: configure_networking(): call to /sbin/dhcpcd complete")
if not GLIUtility.exitsuccess(status):
raise GLIException("DHCPError", 'fatal', 'configure_networking', "Failed to get a dhcp address for " + interface + ".")
elif type == "manual" and self._configuration.get_interactive():
# Drop to bash shell and let them configure it themselves
print "Please configure & test your network device."
GLIUtility.spawn_bash()
elif type == "manual" and not self._interactive.get_interactive():
print "You cannot manually configure the network in non-interactive mode!"
print "Please fix either the network settings or the interactive mode!"
sys.exit(1)
elif type == "static":
if self._configuration.get_verbose(): self._logger.log("DEBUG: configure_networking(): setting static IP")
# Configure the network from the settings they gave.
net_interface = self._configuration.get_network_interface()
net_ip = self._configuration.get_network_ip()
net_broadcast = self._configuration.get_network_broadcast()
net_netmask = self._configuration.get_network_netmask()
if not GLIUtility.set_ip(net_interface, net_ip, net_broadcast, net_netmask):
raise GLIException("SetIPError", 'fatal', 'configure_networking', "Could not set the IP address!")
route = self._configuration.get_network_gateway()
if not GLIUtility.set_default_route(route):
raise GLIException("DefaultRouteError", 'fatal','configure_networking', "Could not set the default route!")
dns_servers = self._configuration.get_dns_servers()
if dns_servers:
try:
resolv_conf = open("/etc/resolv.conf", "w")
for dns_server in dns_servers:
resolv_conf.write("nameserver " + dns_server + "\n")
resolv_conf.close()
except:
raise GLIException("DNSServerError", 'fatal','configure_networking', "Could not set the DNS servers!")
if self._configuration.get_verbose(): self._logger.log("DEBUG: configure_networking(): done setting static IP")
def _configure_grub(self):
self.build_mode = self._install_profile.get_kernel_build_method()
self._gather_grub_drive_info()
root = self._chroot_dir
exitstatus2, kernel_names = GLIUtility.spawn("ls -1 --color=no " +
root + "/boot/pentoo",
return_output=True)
self._logger.log("Output of Kernel Names:\n" + kernel_names)
if not GLIUtility.exitsuccess(exitstatus2):
raise GLIException("BootloaderError", 'fatal', '_configure_grub',
"Error listing the kernels in /boot")
if self.build_mode == "genkernel" or self._install_profile.get_kernel_source_pkg(
) == "livecd-kernel":
exitstatus3, initrd_names = GLIUtility.spawn(
"ls -1 --color=no " + root + "/boot/pentoo.igz",
return_output=True)
self._logger.log("Output of Initrd Names:\n" + initrd_names)
if not GLIUtility.exitsuccess(exitstatus3):
raise GLIException("BootloaderError", 'fatal', '_configure_grub',
"Error listing the initrds")
self._logger.log(
"Bootloader: the three information gathering commands have been run"
)
if not kernel_names[0]:
raise GLIException(
"BootloaderError", 'fatal', '_configure_grub',
"Error: We have no kernel in /boot to put in the grub.conf file!"
)
#-------------------------------------------------------------
#OK, now that we have all the info, let's build that grub.conf
newgrubconf = ""
newgrubconf += "default 0\ntimeout 30\n"
if self.foundboot: #we have a /boot
newgrubconf += "splashimage=(" + self.grub_boot_drive + "," + self.grub_boot_minor + ")/grub/splash.xpm.gz\n"
else: #we have / and /boot needs to be included
newgrubconf += "splashimage=(" + self.grub_boot_drive + "," + self.grub_boot_minor + ")/boot/grub/splash.xpm.gz\n"
if self._install_profile.get_bootloader_kernel_args():
bootloader_kernel_args = self._install_profile.get_bootloader_kernel_args(
)
else:
bootloader_kernel_args = ""
kernel_names = map(string.strip, kernel_names.strip().split("\n"))
initrd_names = map(string.strip, initrd_names.strip().split("\n"))
grub_kernel_name = kernel_names[-1].split(root)[-1]
if initrd_names: grub_initrd_name = initrd_names[-1].split(root)[-1]
# for i in range(len(kernel_names)):
# grub_kernel_name = kernel_names[i].split(root)[-1]
# for i in range(len(initrd_names)): #this should be okay if blank.
# grub_initrd_name = initrd_names[i].split(root)[-1]
#i think this means take the last one it finds.. i.e. the newest.
newgrubconf += "title=Gentoo Linux\n"
newgrubconf += "root (" + self.grub_boot_drive + "," + self.grub_boot_minor + ")\n"
if self.build_mode != "genkernel" and self._install_profile.get_kernel_source_pkg(
) != "livecd-kernel": #using CUSTOM kernel
if self.foundboot:
newgrubconf += "kernel " + grub_kernel_name[
5:] + " root=" + self.root_device + self.root_minor + "\n"
else:
newgrubconf += "kernel /boot" + grub_kernel_name[
5:] + " root=" + self.root_device + self.root_minor + "\n"
else: #using genkernel so it has an initrd.
if self.foundboot:
newgrubconf += "kernel " + grub_kernel_name[
5:] + " root=/dev/ram0 init=/linuxrc ramdisk=8192 real_root="
newgrubconf += self.root_device + self.root_minor + " " + bootloader_kernel_args + "\n"
newgrubconf += "initrd " + grub_initrd_name[5:] + "\n"
else:
newgrubconf += "kernel /boot" + grub_kernel_name[
5:] + " root=/dev/ram0 init=/linuxrc ramdisk=8192 real_root="
newgrubconf += self.root_device + self.root_minor + " " + bootloader_kernel_args + "\n"
newgrubconf += "initrd /boot" + grub_initrd_name[5:] + "\n"
newgrubconf = self._grub_add_windows(newgrubconf)
#now make the grub.conf file
file_name = root + "/boot/grub/grub.conf"
try:
shutil.move(file_name, file_name + ".OLDdefault")
except:
pass
f = open(file_name, 'w')
f.writelines(newgrubconf)
f.close()
self._logger.log(
"Grub installed and configured. Contents of grub.conf:\n" +
newgrubconf)
self._logger.log(
"Grub has not yet been run. If a normal install, it will now be run."
)
def _configure_yaboot(self):
build_mode = self._install_profile.get_kernel_build_method()
root_device = ""
root_minor = ""
parts = self._install_profile.get_partition_tables()
for device in parts:
tmp_partitions = parts[device]
for partition in tmp_partitions:
mountpoint = tmp_partitions[partition]['mountpoint']
if mountpoint == "/":
root_minor = str(int(tmp_partitions[partition]['minor']))
root_device = device
if self._install_profile.get_bootloader_kernel_args(): bootloader_kernel_args = self._install_profile.get_bootloader_kernel_args()
else: bootloader_kernel_args = ""
#Assuming the config program works as specified, it should do the majority of the work.
#this is the white rabbit object. antarus: it expects a full fstab, /proc mounted, and a kernel in /boot/vmlinux. The manaul also says /dev must be bind-mounted.
exitstatus = GLIUtility.spawn("yabootconfig --chroot "+self._chroot_dir+" --quiet", display_on_tty8=True)
if not GLIUtility.exitsuccess(exitstatus):
raise GLIException("YabootError",'fatal','_configure_yaboot',"Could not successfully run the yabootconfig command.")
#Hopefully now an /etc/yaboot.conf exists but does not have the correct kernel/Sysmap information.
#We must gather that info like we have done for the other bootloaders.
file_name = self._chroot_dir + "/boot/kernel_name"
file_name2 = self._chroot_dir + "/boot/initrd_name"
exitstatus2 = GLIUtility.spawn("ls "+root+"/boot/kernel-* > "+file_name)
if build_mode == "genkernel":
exitstatus3 = GLIUtility.spawn("ls "+root+"/boot/initramfs-* > "+file_name2)
else:
exitstatus3 = GLIUtility.spawn("touch "+file_name2)
if (exitstatus2 != 0) or (exitstatus3 != 0):
raise GLIException("BootloaderError", 'fatal', '_configure_yaboot', "Error in one of THE TWO run commands")
self._logger.log("Bootloader: the three information gathering commands have been run")
g = open(file_name)
h = open(file_name2)
initrd_name = h.readlines()
kernel_name = g.readlines()
g.close()
h.close()
if not kernel_name[0]:
raise GLIException("BootloaderError", 'fatal', '_configure_yaboot',"Error: We have no kernel in /boot to put in the yaboot.conf file!")
kernel_name = map(string.strip, kernel_name)
initrd_name = map(string.strip, initrd_name)
for i in range(len(kernel_name)):
kernel_name = kernel_name[i].split(root)[1]
for i in range(len(initrd_name)):
initrd_name = initrd_name[i].split(root)[1]
#Open the file and edit the right lines
f = open(self._chroot_dir+"/etc/yaboot.conf")
contents = f.readlines()
f.close()
for i in range(0, len(contents)):
if contents[i] == "image=/boot/vmlinux":
contents[i] = "image=/boot/"+kernel_name[5:]
if build_mode == "genkernel":
#insert /dev/ram0 line
contents.insert("root=/dev/ram0",i+2)
#insert partition line.
contents.insert("partition="+root_minor,i+3)
#edit append line. use root_device and root_minor.
contents.insert("append=\"real_root="+root_device+root_minor+ " init=/linuxrc "+bootloader_kernel_args + "\" \n", i+4)
f = open(self._chroot_dir+"/etc/yaboot.conf",'w')
f.writelines(contents)
f.close()
