def is_fat(self, partition): """ Returns True if the partition (str) is a fat32 partition. False if not. """ part = lib.return_partition(partition) fs = part.fileSystem.type if fs in ("fat16", "fat32"): return True return False
def install(self): """ Installs the bootloader on the specified device. """ target = self.settings["target"] if not target: # No target, we should get one. try: target = self.modules_settings["partdisks"]["root"] except: # We can't get a target raise m.UserError("Please specify target device.") # Get partition part = lib.return_partition(target) if part == None: raise m.UserError("Target device %s not found." % target) directory = os.path.join(self.main_settings["target"], "syslinux") bootloader = self.settings["bootloader"] if not bootloader: # We should get the bootloader ourselves. # What this means? We need to check for the partition type and set the appropiate bootloader. fs = part.fileSystem.type if fs in ("fat32"): bootloader = "syslinux" elif fs in ("ext2","ext3","ext4"): args = "-i '%(location)s'" % {"location":target} bootloader = "extlinux" if bootloader == "syslinux": args = "-i -d '%(dir)s' '%(location)s'" % {"dir":directory,"location":target} elif bootloader == "extlinux": # Generate extlinux configuration file (FIXME) with open(os.path.join(directory, "extlinux.cfg"), "w") as f: f.write("include syslinux.cfg\n") # Install MBR (warning: we do not make backups! Are they needed on USB drives MBR?) # FIXME: maybe find a cooler way to do this? m.sexec("dd if=/usr/lib/extlinux/mbr.bin of='%s' bs=440 count=1" % lib.return_device(target)) args = "-i '%(dir)s'" % {"dir":directory} verbose("Selected location: %s" % target) m.sexec("%(bootloader)s %(args)s" % {"bootloader":bootloader, "args":args}) # Make partition bootable... verbose("Making partition bootable...") lib.setFlag(part, "boot") lib.commit(part, (target)) # Commit
def start(self): """ Start override to unsquash. """ if "partdisks" in self.modules_settings: settings = self.modules_settings["partdisks"] else: settings = self.settings # Mount root partition. root = settings["root"] # Ensure that is unmounted if os.path.ismount(self.main_settings["target"]): # Target mounted. Unmount lib.umount(path=self.main_settings["target"]) if lib.is_mounted(root): # Partition mounted. Unmount lib.umount(path=root) # Then mount at TARGET lib.mount_partition(path=root, target=self.main_settings["target"]) used = [] # Mount every partition which has "useas" on it # Get changed. try: changed = self.modules_settings["partdisks"]["changed"] except: # Pass changed = {} mountpo = [] changeslist = {} # Regenerate changed to sort it sanely for key, value in changed.items(): if not "useas" in value["changes"]: # There isn't "useas" in changes; skipping this item continue mountpo.append(value["changes"]["useas"]) changeslist[value["changes"]["useas"]] = key mountpo.sort() for point in mountpo: # Get correct partition key = changeslist[point] # Get value value = changed[key] # Get useas useas = value["changes"]["useas"] if useas in ("/","swap"): # Root or swap, do not use it continue # Mount key to mountpoint if lib.is_mounted(key): # Umount lib.umount(path=key) if useas == "/boot/efi": # If this is going to be the /boot/efi partition # we should make sure that it's going to have the # proper partition type set to EFI System Partition lib.prepareforEFI(lib.return_partition(key)) # If we mount_on_install, simply set drop to False, as we should use it anyway if ("mount_on_install" in value["changes"] and value["changes"]["mount_on_install"]) or useas in ("/boot","/boot/efi"): # Create mountpoint mountpoint = self.main_settings["target"] + useas # useas begins with a /, so os.path.join doesn't work if not os.path.exists(mountpoint): os.makedirs(mountpoint) lib.mount_partition(path=key, target=mountpoint) # Partition will be used during unsquash, we should remember when linstaller will execute revert used.append(key) # Store used self.settings["used"] = used