def resetRootDevice(self): """ Formats root device (according LVM default scheme) and adjusts all pointers to allow reinstall the system correctly. Important: this method is directly related to LVM default partitioning scheme. It assumes that root device is under /dev/mapper/vg_root-lv_root path. If this default scheme changes on future, this method must be revisited to assure its functionality. @rtype: bool @return: True if everything is ok, False otherwise """ # restart LVM volume groups to assure its functionality self.__logger.info('Restarting LVM...') lvm.stop() lvm.start(self.__tolerantMode) # wait for udev to handle all events if run(CMD_UDEV_SETTLE) != 0: raise RuntimeError('Error: udevadm settle failure') # Do not trust content from / partition. User can screw up # with its / partition and try a reinstall to fix it. Thus # our code cannot trust on reading content from old and dirty # / partition. We can just infere /boot partition by # appending 2 to the detected disk. installed_disk = self.getPreviousInstalledDisk() boot_partition = self.genBootPartitionName(installed_disk) self.__bootDevice = boot_partition # check multipath self.__hasMultipath = self.__diskParameters[installed_disk.split('/')[-1]]['mpath'] # as consequence, configure prep device path self.__prepDevice = self.__bootDevice[:-1] + "1" # update root, log, data and swap paths self.__rootDevice = '/dev/mapper/%s-%s' % (VGROOT, LVROOT) self.__logDevice = '/dev/mapper/%s-%s' % (VGLOG, LVLOG) self.__dataDevice = '/dev/mapper/%s-%s' % (VGDATA, LVDATA) self.__swapDevice = '/dev/mapper/%s-%s' % (VGSWAP, LVSWAP) self.__logger.debug("resetRootDevice(): __prepDevice = %s" % self.__prepDevice) self.__logger.debug("resetRootDevice(): __bootDevice = %s" % self.__bootDevice) self.__logger.debug("resetRootDevice(): __rootDevice = %s" % self.__rootDevice) self.__logger.debug("resetRootDevice(): __logDevice = %s" % self.__logDevice) self.__logger.debug("resetRootDevice(): __dataDevice = %s" % self.__dataDevice) self.__logger.debug("resetRootDevice(): __swapDevice = %s" % self.__swapDevice) # format boot, root and swap devices formatPartition(self.__bootDevice) formatPartition(self.__rootDevice) formatSwapPartition(self.__swapDevice) return True
def createDefaultLVMLayout(self, diskName, mpath=False): """ Receives all required parameters to create a default LVM layout on selected disk. @type diskName: str @param diskName: disk to be formatted @type mpath: bool @param mpath: multipath flag @rtype: bool @return: True if everything is ok, False otherwise """ self.__disk = diskName # given disk is not valid: abort if diskName not in self.__diskParameters.keys(): raise PKVMError("PARTITIONER", "DISK", "NO_DISK") try: # partitioning dictionary creator sectors = 512 if self.__diskParameters[diskName]['mpath']: slave = self.__diskParameters[diskName]['slaves'][0] sectors = get_sector_size(slave) else: sectors = get_sector_size(diskName) scheme = PartitionCommand(sectors) # configure parameters to create the commands scheme.setDisk(diskName) scheme.setDiskId(self.__diskParameters[diskName]['id']) scheme.setDiskSize(self.__diskParameters[diskName]['size']) scheme.setMultipathMode(self.__diskParameters[diskName]['mpath']) self.__hasMultipath = self.__diskParameters[diskName]['mpath'] # partition sizes # 'prep': 8Mb # 'boot': 512Mb # 'swap': 8Gb # 'root': 20Gb # 'log' : 10Gb partitionSizes = { 'prep': 8 * 1024, 'boot': 512 * 1024, 'swap': (8 * 1024 * 1024), 'root': (20 * 1024 * 1024), 'log' : (10 * 1024 * 1024) } # conventional commands prep = scheme.createPartition(None, 'Pri', 'prep', partitionSizes['prep'], None, 1) boot = scheme.createPartition('/boot', 'Pri', 'ext3', partitionSizes['boot'] , None, 2) ext = scheme.createPartition(None, 'Ext', 'extended', 0, None, 3) root = scheme.createPartition(None, 'Log', 'lvm', partitionSizes['root'], VGROOT, 5) log = scheme.createPartition(None, 'Log', 'lvm', partitionSizes['log'], VGLOG, 6) swap = scheme.createPartition(None, 'Log', 'lvm', partitionSizes['swap'], VGSWAP, 7) data = scheme.createPartition(None, 'Log', 'lvm', ALL_AVAILABLE, VGDATA, 8) self.__diskCommands = [prep, boot, ext, root, log, swap, data] # lvm commands pv_root = scheme.createPhysicalVolume(root['disk_name'], root['size'], root['name']) pv_log = scheme.createPhysicalVolume(log['disk_name'], log['size'], log['name']) pv_swap = scheme.createPhysicalVolume(swap['disk_name'], swap['size'], swap['name']) pv_data = scheme.createPhysicalVolume(data['disk_name'], data['size'], data['name']) self.__lvmCommands = [pv_root, pv_log, pv_swap, pv_data] vg_root = scheme.createVolumeGroup([root['name']], VGROOT) vg_log = scheme.createVolumeGroup([log['name']], VGLOG) vg_swap = scheme.createVolumeGroup([swap['name']], VGSWAP) vg_data = scheme.createVolumeGroup([data['name']], VGDATA) self.__lvmCommands += [vg_root, vg_log, vg_swap, vg_data] lv_root = scheme.createLogicalVolume(root['vg'], 'ext3', LVROOT, '/', root['size']) lv_log = scheme.createLogicalVolume(log['vg'], 'ext3', LVLOG, '/var/log', log['size']) lv_swap = scheme.createLogicalVolume(swap['vg'], 'swap', LVSWAP, '', swap['size']) lv_data = scheme.createLogicalVolume(data['vg'], 'ext3', LVDATA, '/var/lib/libvirt/images', data['size']) self.__lvmCommands += [lv_root, lv_log, lv_swap, lv_data] # run partitioner instructions to clean and partition the disk self.__run(self.__diskParameters[diskName]['mpath'], sectors) # update prep, boot, root, log, data and swap paths path = '/dev/%s' if self.__diskParameters[diskName]['mpath']: path = '/dev/mapper/%s' self.__prepDevice = path % prep['name'] self.__bootDevice = path % boot['name'] self.__rootDevice = '/dev/mapper/%s-%s' % (vg_root['name'], lv_root['name']) self.__logDevice = '/dev/mapper/%s-%s' % (vg_log['name'], lv_log['name']) self.__dataDevice = '/dev/mapper/%s-%s' % (vg_data['name'], lv_data['name']) self.__swapDevice = '/dev/mapper/%s-%s' % (vg_swap['name'], lv_swap['name']) # devices to be formatted as ext4 devices = [ self.__bootDevice, self.__rootDevice, self.__logDevice, self.__dataDevice ] # format devices for dev in devices: if formatPartition(dev) == False: raise PKVMError("PARTITIONER", "FORMAT", "ERROR") # devices to be formatted as swap swapDevices = [self.__swapDevice] # format swap devices for dev in swapDevices: if formatSwapPartition(dev) == False: raise PKVMError("PARTITIONER", "FORMAT", "ERROR") except PKVMError as e: raise except Exception as e: self.__logger.critical("Unexpected error") self.__logger.critical("EXCEPTION:" + str(type(e))) self.__logger.critical(str(e)) self.__logger.critical("Stacktrace:" + str(traceback.format_exc())) raise PKVMError("PARTITIONER", "ERROR", "ERROR") return True