def install_grub2(self, device, directory): boot_folder = directory+"boot" dev = device[:8] output,erro,ret = run_simple_command_echo("grub-install \ --root-directory={0} {1}".format(directory, dev),True) if ret is not 0: log.error("error output={0} command output={1}".format(erro,output)) return False else: return True
def grub_version(): try: version = os.popen("grub-install --version").read() except: log.error("Grub is not installed") return False if "0.97" in version: return "grub-legacy" elif "1." in version: return "grub2" elif "GNU" in version: return "grub-legacy"
def build_grub2_menu(self, directory, arq=None): boot_folder = directory+"boot" if arq is None: arq = "grub.cfg" output,erro,ret = run_simple_command_echo("grub-mkconfig -o \ {0}/grub/{1}".format(boot_folder,arq),True) if ret is not 0: log.error("Generating Grub2 config file failed") log.error("error output={0} command output={1}".format(erro,output)) return False else: return True
def install_grub_legacy(self, device, directory): ''' install grub-legacy in sdX, giving de mounted device as the root device ''' boot_folder = directory+"boot" dev = device[:8] try: output,erro,ret = run_simple_command_echo("grub-install \ --root-directory={0} {1}".format(directory, dev),True) except: run_simple_command_echo("grep -v rootfs /proc/mounts > /etc/mtab") output,erro,ret = run_simple_command_echo("grub-install \ --root-directory={0} {1}".format(directory, dev),True) if ret is not 0: log.error("Grub installation failed. [grub-install \ --root-directory={0} {1}]".format(directory, dev)) log.error("error output={0} command output={1}".format(erro,output)) return False else: return True
def umount_partition(directory): ''' Desmonta a ultima particao montada ou a pasta/particao recebida ''' if directory is None: log.error("directory to umount not received") return None run_simple_command_echo("sync") output,erro,ret = run_simple_command_echo("umount {0}".format(directory),True) if ret is 0: #pops the mounted folder from the list for i in mounted_devices: if directory in i: mounted_devices.pop(mounted_devices.index(i)) else: log.error("error output={0} command output={1}".format(erro,output)) return ret
def mount_partition(device, folder = None): ''' Monta a particao recebida.(Ex.: /dev/sda1) Caso 'folder' nao tenha um destino valido, a particao eh montada em uma pasta temporaria ''' mount_device = None if folder is None: tmpd = make_temp_dir() else: tmpd = folder if device is None: log.error("No device given") return False output,erro,ret = run_simple_command_echo("mount {0} {1} {2}".format(MOUNT_OPTIONS, device, tmpd),True) if "already" in erro: log.error("{0} is arealdy exclusively mounted.".format(mount_device)) log.info("Trying to umount device above, and re-run") umount_real(mount_device) output,erro,ret = run_simple_command_echo("mount {0} {1} {2}".format(MOUNT_OPTIONS, mount_device, tmpd),True) if ret is not 0: log.error("{0}".format(erro)) #raise ErrorMountingFilesystem if folder is not None: mounted_devices.insert(0, folder) else: mounted_devices.append(tmpd) return tmpd
def install_syslinux(self, device, directory): boot_folder = directory+"boot" dev = device[:8] try: log.info("cp /usr/lib/syslinux/menu.c32 {0}/syslinux".format(boot_folder)) copyFile("/usr/lib/syslinux/menu.c32", boot_folder+"/syslinux") log.info("cp /usr/lib/syslinux/chain.c32 {0}/syslinux".format(boot_folder)) copyFile("/usr/lib/syslinux/chain.c32", boot_folder+"/syslinux") log.info("cp /usr/lib/syslinux/reboot.c32 {0}/syslinux".format(boot_folder)) copyFile("/usr/lib/syslinux/reboot.c32", boot_folder+"/syslinux") log.info("cp /usr/lib/syslinux/poweroff.com {0}/syslinux".format(boot_folder)) copyFile("/usr/lib/syslinux/poweroff.com", boot_folder+"/syslinux") except: log.error("Error copying files") return False try: aux = get_filesystem_type(device) if "fat" in aux: run_simple_command_echo("syslinux -d {0}/syslinux {1}".format(boot_folder,device),True) elif "ext" in aux: log.info("extlinux --install {0}/syslinux".format(boot_folder)) run_simple_command_echo("extlinux --install {0}/syslinux".format(boot_folder),True) else: log.error("Filesystem not accepted.") return False except: log.error("installing syslinux in {0} failed".format(device)) return False try: run_simple_command_echo("dd if=/usr/lib/syslinux/mbr.bin of={0} \ bs=440 conv=notrunc count=1".format(dev),True) except: log.error("dd failed") return False if not get_boot_flag(device): unset_all_boot_flags(device) if set_boot_flag(device): log.info("{0} has been set as bootable device".format(device)) return True
def mount_device(device,folder): ''' Mount devices (as /dev, /sys) Usefull to mount chroot needed devices ''' if folder is None: log.error("No folder as received as mounting point") if device is None: log.error("No device as received to mount") output,erro,ret = run_simple_command_echo("mount -o bind /{0} {1}{0}".format(device, folder),True) if ret is not 0: log.error("error output={0} command output={1}".format(erro,output)) raise ErrorMountingFilesystem mounted_devices.insert(0,"{0}{1}".format(folder,device))
def restore_image(self): """ """ invalid_partitions = False if is_mounted(self.target_device): log.error("The partition {0} is mounted, please umount first, and try again".format(self.target_device)) self.notify_status("mounted_partition_error",{"mounted_partition_error":self.target_device}) raise DeviceIsMounted("Please umount first") self.active = True information = Information(self.image_path) information.load() if self.partitions: information.set_partitions(self.partitions) image_name = information.get_image_name() compressor_level = information.get_image_compressor_level() partitions = information.get_partitions() # Get total size total_bytes = 0 for part in partitions: total_bytes += part.size self.total_blocks = long(math.ceil(total_bytes/float(BLOCK_SIZE))) device = Device(self.target_device) if device.is_disk() != \ information.get_image_is_disk(): log.error("Invalid target device %s" % device.path) self.notify_status("write_error", \ {"write_error":device_path}) raise ErrorRestoringImage("Invalid target device") try: disk = Disk(device) except _ped.DiskLabelException: try: device.fix_disk_label() disk = Disk(device) except: log.error("Unrecognized disk label") raise ErrorRestoringImage("Unrecognized disk label") if information.get_image_is_disk(): if ("msdos" not in disk.getPedDisk().type.name): #se a tabela nao for msdos, recria ela como msdos para nao haver problemas d = disk_new_fresh(device.getPedDevice(), _ped.disk_type_get("msdos")) d.commit_to_dev() disk = Disk(device) #Get total disk target size disk_size = get_disk_size(self.target_device) if (total_bytes > disk_size): log.info("Total size of image is {0}".format(total_bytes)) log.info("Total size of {0} is {1}".format(self.target_device,disk_size)) log.error("The size of {0} is {1}, is not enough to apply the selected image".format(self.target_device, disk_size)) disk_space_info = [] disk_space_info.append(total_bytes) disk_space_info.append(disk_size) self.notify_status("no_enough_space", {"disk_minimum_size":disk_space_info}) raise ErrorRestoringImage("No enough space on disk") log.info("Restoring MBR and Disk Layout") mbr = Mbr(self.image_path) try: mbr.restore_from_file(self.target_device) except Exception as e: log.error("Error to restore the Mbr file") image_path = self.image_path.split("/")[3] + "/mbr.bin" self.notify_status("file_not_found",{"file_not_found":image_path}) raise ErrorFileNotFound("File not Found {0}".format(image_path)) dlm = DiskLayoutManager(self.image_path) #try: if self.expand != 2: dlm.restore_from_file(disk, True) else: dlm.restore_from_file(disk, False) #except Exception as e: # log.error("Error to restore the disk.dl file") # image_path = self.image_path.split("/")[3] + "/disk.dl" # self.notify_status("file_not_found",{"file_not_found":image_path}) # raise ErrorFileNotFound("File not found {0}".format(image_path)) else: parent_path = get_parent_path(self.target_device) parent_device = Device(parent_path) parent_disk = Disk(parent_device) partition = parent_disk.get_partition_by_path( self.target_device, part.type) part_size = partition.getSize('b') if (total_bytes > part_size): part_space_info = [] part_space_info.append(total_bytes) part_space_info.append(part_size) log.error("The partition selected is smaller than the image") self.notify_status("no_enough_space_part", {"disk_minimum_size":part_space_info}) raise ErrorRestoringImage("No enought space on partition") self.timer.start() total_partitions = len(partitions) for part in partitions: total_partitions -= 1 if not self.active: break if (self.expand == 3) and (total_partitions == 0): break if information.get_image_is_disk(): partition = disk.get_partition_by_number(part.number, part.type) else: parent_path = get_parent_path(self.target_device) parent_device = Device(parent_path) parent_disk = Disk(parent_device) partition = parent_disk.get_partition_by_path( self.target_device, part.type) if partition is None: invalid_partitions = True continue log.info("Restoring partition {0}".format(partition.get_path())) self.notify_status("restore_partition",\ {"restoring_partition":partition.get_path()}) invalid_partitions = False if hasattr(part, "uuid"): partition.filesystem.open_to_write(part.uuid) else: partition.filesystem.open_to_write() if hasattr(part, "label"): partition.filesystem.write_label(part.label) if partition.filesystem.is_swap(): continue pattern = FILE_PATTERN.format(name=image_name, partition=part.number, volume="{volume}") volumes = 1 if hasattr(part, "volumes"): volumes = part.volumes try: image_reader = ImageReaderFactory(self.image_path, pattern, volumes, compressor_level, self.notify_status) except Exception as e: log.info(e) extract_callback = None if compressor_level: compressor = Compressor(compressor_level) extract_callback = compressor.extract self.buffer_manager = BufferManagerFactory(image_reader.read_block, self.notify_status, extract_callback) # open the file after instantiating BufferManager, cause of a # problem on multiprocessing module, FD_CLOEXE doesn't work # (I don't want to dup the file descriptor). image_reader.open() self.buffer_manager.start() buffer = self.buffer_manager.output_buffer while self.active: try: data = buffer.get() except IOError, e: if e.errno == errno.EINTR: self.notify_status("read_buffer_error",{"read_buffer_error":str(e)}) data = "" self.cancel() raise ErrorReadingFromDevice(e) break if data == EOF: break try: partition.filesystem.write_block(data) except ErrorWritingToDevice, e: self.notify_status("write_partition_error") if not self.canceled: self.stop() raise e self.processed_blocks += 1
if self.expand != 2: if information.get_image_is_disk(): self.expand_last_partition(self.expand) if self.canceled: self.notify_status("canceled", {"operation": "Restore image"}) else: self._finish() log.info("Restoration finished") log.info("Iniciando gtk grubinstall") cmd = "{0}".format(which("grubinstall")) try: os.system("{0} &".format(cmd)) except: log.error("Erro ao iniciar grubinstall. {0}".format(e)) def expand_last_partition(self,opt_expand): # After all data is copied to the disk # we instance class again to reload sync() device = Device(self.target_device) disk = Disk(device) partition = disk.get_last_partition() if partition is not None: if partition.type == PARTITION_NORMAL: expander = PartitionExpander(device.path) log.info("Checking and try expand {0}".format(partition.get_path())) new_size = expander.try_expand() log.info("The new_size of the disk will be {0}".format(new_size))
def try_expand(self): """ """ device = parted.Device(self.path) disk = parted.Disk(device) try: last_partition = disk.partitions[-1] except IndexError: log.error("The disk has no partitions") return -1 # A partição deve ser primária e conter NTFS como sistema # de arquivos if last_partition.type != parted.PARTITION_NORMAL: log.error("The partition must be primary") return -1 if last_partition.fileSystem is None: log.error("The partition hasn't filesystem") return -1 #if last_partition.fileSystem is not None: # if last_partition.fileSystem.type != "ntfs": # log.error("We only support ntfs filesystem for now") # return -1 # Recria a última partição do disco utilizando # todo o espaço que desalocado start = last_partition.geometry.start fs = last_partition.fileSystem ped = last_partition.getPedPartition() disk.removePartition(last_partition) new_geometry = None if (len(disk.getFreeSpaceRegions()) == 1): new_geometry = disk.getFreeSpaceRegions()[0] new_geometry.start = start else: new_geometry = None for region in disk.getFreeSpaceRegions(): if region.start == start: new_geometry = region if (start > region.start and start < region.end): new_geometry = region new_geometry.start = start constraint = parted.Constraint(exactGeom=new_geometry) new_partition = parted.Partition(disk = disk, type = parted.PARTITION_NORMAL, fs = fs, geometry = new_geometry, PedPartition = ped) disk.addPartition(partition=new_partition, constraint=constraint) try: disk.commit() except: try: disk.commitToDevice() disk.commitToOS() except Exception as e: log.error("PartitionExpander : {0}".format(e)) # Após criar a tabela de partição temos que fazer # com o kernel releia essa tabela. Será preciso # fazer isso para dar continuidade ao processo attempt = 0 while True: p = subprocess.Popen("sfdisk -R %s" % device.path, shell = True, stderr = subprocess.PIPE, ) if not len(p.stderr.readlines()): break if attempt >= 5: return -1 attempt += 1 time.sleep(2) # Apos o kernel re-ler a nova tabela de partição # temos que esperar o dispositivo ficar pronto attempt = 0 while True: if os.path.exists(new_partition.path): break if attempt >= 5: return -1 attempt += 1 time.sleep(2) # Agora da um resize no sistema de arquivos # Pegar o tamanho total do dispositivo da partição a ser redimensionada size = new_partition.geometry.length * device.sectorSize return size
def restore_image(self): """ """ if is_mounted(self.target_device): raise DeviceIsMounted("Please umount first") self.active = True information = Information(self.image_path) information.load() if self.partitions: information.set_partitions(self.partitions) image_name = information.get_image_name() compressor_level = information.get_image_compressor_level() partitions = information.get_partitions() # Get total size total_bytes = 0 for part in partitions: total_bytes += part.size self.total_blocks = long(math.ceil(total_bytes / float(BLOCK_SIZE))) device = Device(self.target_device) if device.is_disk() != \ information.get_image_is_disk(): log.error("Invalid target device %s" % device.path) raise ErrorRestoringImage("Invalid target device") try: disk = Disk(device) except _ped.DiskLabelException: try: device.fix_disk_label() disk = Disk(device) except: log.error("Unrecognized disk label") raise ErrorRestoringImage("Unrecognized disk label") if information.get_image_is_disk(): log.info("Restoring MBR and Disk Layout") mbr = Mbr(self.image_path) mbr.restore_from_file(self.target_device) dlm = DiskLayoutManager(self.image_path) dlm.restore_from_file(disk, self.expand) self.timer.start() for part in partitions: if not self.active: break if information.get_image_is_disk(): partition = disk.get_partition_by_number( part.number, part.type) else: parent_path = get_parent_path(self.target_device) parent_device = Device(parent_path) parent_disk = Disk(parent_device) partition = parent_disk.get_partition_by_path( self.target_device, part.type) log.info("Restoring partition {0}".format(partition.get_path())) if partition is None: raise ErrorRestoringImage("No valid partitions found") if hasattr(part, "uuid"): partition.filesystem.open_to_write(part.uuid) else: partition.filesystem.open_to_write() if hasattr(part, "label"): partition.filesystem.write_label(part.label) if partition.filesystem.is_swap(): continue pattern = FILE_PATTERN.format(name=image_name, partition=part.number, volume="{volume}") volumes = 1 if hasattr(part, "volumes"): volumes = part.volumes image_reader = ImageReaderFactory(self.image_path, pattern, volumes, compressor_level, self.notify_status) extract_callback = None if compressor_level: compressor = Compressor(compressor_level) extract_callback = compressor.extract self.buffer_manager = BufferManagerFactory(image_reader.read_block, extract_callback) # open the file after instantiating BufferManager, cause of a # problem on multiprocessing module, FD_CLOEXE doesn't work # (I don't want to dup the file descriptor). image_reader.open() self.buffer_manager.start() buffer = self.buffer_manager.output_buffer while self.active: try: data = buffer.get() except IOError, e: if e.errno == errno.EINTR: self.cancel() break if data == EOF: break try: partition.filesystem.write_block(data) except ErrorWritingToDevice, e: if not self.canceled: self.stop() raise e self.processed_blocks += 1
def install_boot_manager(self, boot_only_dev=None, dev_boot_tuples=None): #dev_boot_tuples --> lista de duplas do tipo (particao_boot_sistema1, particao_sistema1) self.dev_boot_tuples = dev_boot_tuples directory = mount_partition(self.device) boot_folder = directory+"boot" if (boot_only_dev is not None) and (boot_only_dev): mount_partition(boot_only_dev,directory+"boot") if "grub2" in self.boot_manager: boot_opt = Grub2() if self.chroot_option: directory,self.real_root = chroot(directory) if self.make_config_file: #on live cd, this only works under chroot if not self.chroot_option: directory,self.real_root = chroot(directory) if boot_opt.build_grub2_menu(directory): log.warning("Grub2 config file generated") if boot_opt.install_grub2(self.device, directory): log.warning("Grub2 successfully installed") else: log.error("Installing Grub2 failed") elif "grub" in self.boot_manager: boot_opt=GrubLegacy() if self.chroot_option: directory,self.real_root = chroot(directory) boot_folder="/boot" version=grub_version() if ("grub-legacy" in version) and version: if self.make_config_file: boot_opt.build_grub_legacy_menu(boot_folder,dev_boot_tuples) if boot_opt.install_grub_legacy(self.device, directory): log.warning("Grub-Legacy successfully installed") else: log.error("Installing Grub-Legacy failed") else: boot_opt = Grub2() log.error("Grub-legacy is not installed in {0}".format(self.device)) log.warning("INSTALING GRUB2 INSTEAD") if self.make_config_file: if boot_opt.build_grub2_menu(directory): log.warning("Grub2 config file generated") if boot_opt.install_grub2(self.device, directory): log.warning("Grub2 successfully installed") else: log.error("Installing Grub2 failed") elif "syslinux" in self.boot_manager: boot_opt = Syslinux() if self.chroot_option: directory,self.real_root=chroot(directory) boot_folder="/boot" if self.make_config_file: boot_opt.build_sislinux_menu(boot_folder,dev_boot_tuples) if boot_opt.install_syslinux(self.device,directory): log.warning("Syslinux successfully installed") else: log.error("Installing Syslinux failed") if self.chroot_option: try: undo_chroot(self.real_root) except: log.error("chroot exit failed") umount_all_devices() umount_all_devices_system()
def restore_image(self): """ """ if is_mounted(self.target_device): raise DeviceIsMounted("Please umount first") self.active = True information = Information(self.image_path) information.load() if self.partitions: information.set_partitions(self.partitions) image_name = information.get_image_name() compressor_level = information.get_image_compressor_level() partitions = information.get_partitions() # Get total size total_bytes = 0 for part in partitions: total_bytes += part.size self.total_blocks = long(math.ceil(total_bytes/float(BLOCK_SIZE))) device = Device(self.target_device) if device.is_disk() != \ information.get_image_is_disk(): log.error("Invalid target device %s" % device.path) raise ErrorRestoringImage("Invalid target device") try: disk = Disk(device) except _ped.DiskLabelException: try: device.fix_disk_label() disk = Disk(device) except: log.error("Unrecognized disk label") raise ErrorRestoringImage("Unrecognized disk label") if information.get_image_is_disk(): log.info("Restoring MBR and Disk Layout") mbr = Mbr(self.image_path) mbr.restore_from_file(self.target_device) dlm = DiskLayoutManager(self.image_path) dlm.restore_from_file(disk, self.expand) self.timer.start() for part in partitions: if not self.active: break if information.get_image_is_disk(): partition = disk.get_partition_by_number(part.number, part.type) else: parent_path = get_parent_path(self.target_device) parent_device = Device(parent_path) parent_disk = Disk(parent_device) partition = parent_disk.get_partition_by_path( self.target_device, part.type) log.info("Restoring partition {0}".format(partition.get_path())) if partition is None: raise ErrorRestoringImage("No valid partitions found") if hasattr(part, "uuid"): partition.filesystem.open_to_write(part.uuid) else: partition.filesystem.open_to_write() if hasattr(part, "label"): partition.filesystem.write_label(part.label) if partition.filesystem.is_swap(): continue pattern = FILE_PATTERN.format(name=image_name, partition=part.number, volume="{volume}") volumes = 1 if hasattr(part, "volumes"): volumes = part.volumes image_reader = ImageReaderFactory(self.image_path, pattern, volumes, compressor_level, self.notify_status) extract_callback = None if compressor_level: compressor = Compressor(compressor_level) extract_callback = compressor.extract self.buffer_manager = BufferManagerFactory(image_reader.read_block, extract_callback) # open the file after instantiating BufferManager, cause of a # problem on multiprocessing module, FD_CLOEXE doesn't work # (I don't want to dup the file descriptor). image_reader.open() self.buffer_manager.start() buffer = self.buffer_manager.output_buffer while self.active: try: data = buffer.get() except IOError, e: if e.errno == errno.EINTR: self.cancel() break if data == EOF: break try: partition.filesystem.write_block(data) except ErrorWritingToDevice, e: if not self.canceled: self.stop() raise e self.processed_blocks += 1
def create_image(self): """ """ if is_mounted(self.device_path): raise DeviceIsMounted("Please umount first") self.active = True device = Device(self.device_path) disk = Disk(device) if device.is_disk(): mbr = Mbr(self.target_path) mbr.save_to_file(self.device_path) dlm = DiskLayoutManager(self.target_path) dlm.save_to_file(disk) partition_list = disk.get_valid_partitions(self.raw) if not partition_list: raise ErrorCreatingImage("Partition(s) hasn't a " +\ "valid filesystem") # check partitions filesystem if not self.raw: for part in partition_list: log.info("Checking filesystem of {0}".format(part.get_path())) self.notify_status("checking_filesystem", {"device": part.get_path()}) if not part.filesystem.check(): log.error("{0} Filesystem is not clean".\ format(part.get_path())) raise ErrorCreatingImage("{0} Filesystem is not clean".\ format(part.get_path())) # fill partitions with zeroes if self.raw and self.fill_with_zeros: for part in partition_list: log.info("{0} Filling with zeros".format(part.get_path())) self.notify_status("filling_with_zeros", {"device": part.get_path()}) part.filesystem.fill_with_zeros() # get total size total_bytes = 0 for part in partition_list: total_bytes += part.filesystem.get_used_size() self.total_blocks = long(math.ceil(total_bytes/float(BLOCK_SIZE))) information = Information(self.target_path) information.set_image_is_disk(device.is_disk()) information.set_image_name(self.image_name) information.set_image_compressor_level(self.compressor_level) # TODO: Abstract this whole part, when creating isos, # splitting in files, etc... self.timer.start() remaining_size = self.split_size if self.create_iso: remaining_size -= BASE_SYSTEM_SIZE slices = dict() # Used when creating iso iso_volume = 1 # Used when creating iso for part in partition_list: if not self.active: break log.info("Creating image of {0}".format(part.get_path())) number = part.get_number() uuid = part.filesystem.uuid() label = part.filesystem.read_label() type = part.filesystem.type part.filesystem.open_to_read() compact_callback = None if self.compressor_level: compressor = Compressor(self.compressor_level) compact_callback = compressor.compact self.buffer_manager = BufferManagerFactory( part.filesystem.read_block, compact_callback) self.buffer_manager.start() buffer = self.buffer_manager.output_buffer volumes = 1 while self.active: total_written = 0 # Used to help splitting the file pattern = FILE_PATTERN.format(name=self.image_name, partition=number, volume=volumes) file_path = self.target_path + pattern fd = open(file_path, "wb") next_partition = False while self.active: try: data = buffer.get() except IOError, e: if e.errno == errno.EINTR: self.cancel() break if data == EOF: next_partition = True if self.create_iso: remaining_size -= total_written if not slices.has_key(iso_volume): slices[iso_volume] = list() slices[iso_volume].append(file_path) break fd.write(data) self.processed_blocks += 1 if self.split_size: bytes_written = len(data) total_written += bytes_written if (total_written + bytes_written) >= remaining_size: volumes += 1 remaining_size = self.split_size if self.create_iso: if not slices.has_key(iso_volume): slices[iso_volume] = list() slices[iso_volume].append(file_path) iso_volume += 1 break fd.close() if next_partition: break self.buffer_manager.join() part.filesystem.close() information.add_partition(number, type, volumes, part.filesystem.get_used_size(), uuid, label)
def create_image(self): """ """ if is_mounted(self.device_path): log.error("The partition {0} is mounted, please umount first, and try again".format(self.device_path)) self.notify_status("mounted_partition_error",{"mounted_partition_error":self.device_path}) raise DeviceIsMounted("Please umount first") self.active = True device = Device(self.device_path) disk = Disk(device) if device.is_disk(): try: mbr = Mbr(self.target_path) mbr.save_to_file(self.device_path) dlm = DiskLayoutManager(self.target_path) dlm.save_to_file(disk) except Exception as e: log.info(e) self.notify_status("write_error", \ {"write_error":self.target_path}) raise ErrorWritingToDevice("Write error in {0}".format(self.target_path)) partition_list = disk.get_valid_partitions(self.raw) if not partition_list: raise ErrorCreatingImage("Partition(s) hasn't a " +\ "valid filesystem") # check partitions filesystem if not self.raw: for part in partition_list: log.info("Checking filesystem of {0}".format(part.get_path())) self.notify_status("checking_filesystem", {"device": part.get_path()}) if not part.filesystem.check(): log.error("{0} Filesystem is not clean".\ format(part.get_path())) raise ErrorCreatingImage("{0} Filesystem is not clean".\ format(part.get_path())) # fill partitions with zeroes if self.raw and self.fill_with_zeros: for part in partition_list: log.info("{0} Filling with zeros".format(part.get_path())) self.notify_status("filling_with_zeros", {"device": part.get_path()}) part.filesystem.fill_with_zeros() # get total size total_bytes = 0 for part in partition_list: total_bytes += part.filesystem.get_used_size() self.total_blocks = long(math.ceil(total_bytes/float(BLOCK_SIZE))) information = Information(self.target_path) information.set_image_is_disk(device.is_disk()) information.set_image_name(self.image_name) information.set_image_compressor_level(self.compressor_level) if device.is_disk(): disk_info = DiskInfo() disk_dict = disk_info.formated_disk(self.device_path) information.set_disk_size(disk_dict["size"]) # TODO: Abstract this whole part, when creating isos, # splitting in files, etc... self.timer.start() remaining_size = self.split_size if self.create_iso: remaining_size -= BASE_SYSTEM_SIZE slices = dict() # Used when creating iso iso_volume = 1 # Used when creating iso for part in partition_list: if not self.active: break log.info("Creating image of {0}".format(part.get_path())) self.notify_status("image_creator", \ {"image_creator ": part.get_path()}) number = part.get_number() uuid = part.filesystem.uuid() label = part.filesystem.read_label() type = part.filesystem.type part.filesystem.open_to_read() #check if partclone is running if type in ("ext2","ext3","ext4"): self.partclone_stderr = part.filesystem.get_error_ext() compact_callback = None if self.compressor_level: compressor = Compressor(self.compressor_level) compact_callback = compressor.compact self.buffer_manager = BufferManagerFactory( part.filesystem.read_block, self.notify_status, compact_callback) self.buffer_manager.start() buffer = self.buffer_manager.output_buffer volumes = 1 while self.active: total_written = 0 # Used to help splitting the file pattern = FILE_PATTERN.format(name=self.image_name, partition=number, volume=volumes) file_path = self.target_path + pattern try: fd = open(file_path, "wb") except Exception as e: log.info(e) self.notify_status("open_file", \ {"open_file":file_path}) raise ImageNotFound("The file wasn't found {0}". \ format(file_path)) next_partition = False while self.active: try: data = buffer.get() except IOError, e: #self.notify_status("read_buffer_error", \ # {"read_buffer_error":str(e)}) if e.errno == errno.EINTR: self.notify_status("read_buffer_error", \ {"read_buffer_error":str(e)}) data = "" self.cancel() raise ErrorReadingFromDevice(e) break if data == EOF: if (self.partclone_stderr != None): self.data_is_eof = True while self.partclone_sucess == False: pass self.partclone_stderr = None self.partclone_sucess = False self.data_is_eof = False next_partition = True if self.create_iso: remaining_size -= total_written if not slices.has_key(iso_volume): slices[iso_volume] = list() slices[iso_volume].append(file_path) break try: fd.write(data) except Exception as e: log.info("{0}".format(e)) self.notify_status("disk_full") self.cancel() raise ErrorWritingToDevice("Error in write file {0}".\ format(file_path)) self.processed_blocks += 1 if self.split_size: bytes_written = len(data) total_written += bytes_written if (total_written + bytes_written) >= remaining_size: volumes += 1 remaining_size = self.split_size if self.create_iso: if not slices.has_key(iso_volume): slices[iso_volume] = list() slices[iso_volume].append(file_path) iso_volume += 1 break try: fd.close() except Exception as e: log.info(e) self.notify_status("write_error",{"write_error":e}) raise ErrorCloseToWrite("Close Error {0}".format(e)) if next_partition: break self.buffer_manager.join() part.filesystem.close() information.add_partition(number, type, volumes, part.filesystem.get_used_size(), uuid, label)