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
def restore_image(self): """ """ information = Information(self.image_path) information.load() image_name = information.get_image_name() compressor_level = information.get_image_compressor_level() total_bytes = information.get_image_total_bytes() total_blocks = long(math.ceil(total_bytes / float(BLOCK_SIZE))) compressor = Compressor(compressor_level) device = Device(self.target_device) if device.is_disk() != \ information.get_image_is_disk(): raise ErrorRestoringImage("Invalid target dispositive") try: disk = Disk(device) except _ped.DiskLabelException: try: device.fix_disk_label() disk = Disk(device) except: raise ErrorRestoringImage("Unrecognized disk label") if information.get_image_is_disk(): mbr = Mbr(self.image_path) mbr.restore_from_file(self.target_device) dlm = DiskLayoutManager(self.image_path) dlm.restore_from_file(disk) self._print_informations(total_bytes, image_name) progress = Progress(total_blocks) progress.start() partitions = information.get_partitions() for p in partitions: if information.get_image_is_disk(): partition = disk.get_partition_by_number(p.number, p.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, p.type) if partition is None: raise ErrorRestoringImage("No valid partitions found") if p.uuid is not None: partition.filesystem.open_to_write(p.uuid) else: partition.filesystem.open_to_write() if partition.filesystem.is_swap(): continue file_name = FILE_PATTERN % (image_name, p.number) with open(self.image_path + file_name, 'rb') as f: # TODO: Work with parallelism while True: # Ugly header = f.read(compressor.get_header_size()) if not len(header): break size = compressor.read_block_header(header) cdata = f.read(size) data = compressor.extract(cdata) partition.filesystem.write(data) progress.increment(1) partition.filesystem.close() progress.stop() print "completed."
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 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 restore_image(self): """ """ information = Information(self.image_path) information.load() image_name = information.get_image_name() compressor_level = information.get_image_compressor_level() total_bytes = information.get_image_total_bytes() total_blocks = long(math.ceil(total_bytes/float(BLOCK_SIZE))) device = Device(self.target_device) if device.is_disk() != \ information.get_image_is_disk(): raise ErrorRestoringImage("Invalid target dispositive") try: disk = Disk(device) except _ped.DiskLabelException: try: device.fix_disk_label() disk = Disk(device) except: raise ErrorRestoringImage("Unrecognized disk label") if information.get_image_is_disk(): mbr = Mbr(self.image_path) mbr.restore_from_file(self.target_device) dlm = DiskLayoutManager(self.image_path) dlm.restore_from_file(disk) self._print_informations(total_bytes, image_name) progress = Progress(total_blocks) progress.start() partitions = information.get_partitions() for part in partitions: 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: raise ErrorRestoringImage("No valid partitions found") if hasattr(part, "uuid"): partition.filesystem.open_to_write(part.uuid) else: partition.filesystem.open_to_write() if partition.filesystem.is_swap(): continue current_volume = 1 while True: file_name = FILE_PATTERN % (image_name, part.number, current_volume) file_path = self.image_path + file_name reader = ReaderFactory(file_path, compressor_level) for data in reader: partition.filesystem.write(data) progress.increment(1) if hasattr(part, "volumes"): if current_volume < part.volumes: current_volume += 1 continue break partition.filesystem.close() progress.stop() print "completed."
def restore_image(self): """ """ information = Information(self.image_path) information.load() image_name = information.get_image_name() compressor_level = information.get_image_compressor_level() total_bytes = information.get_image_total_bytes() total_blocks = long(math.ceil(total_bytes/float(BLOCK_SIZE))) compressor = Compressor(compressor_level) device = Device(self.target_device) if device.is_disk() != \ information.get_image_is_disk(): raise ErrorRestoringImage("Invalid target dispositive") try: disk = Disk(device) except _ped.DiskLabelException: try: device.fix_disk_label() disk = Disk(device) except: raise ErrorRestoringImage("Unrecognized disk label") if information.get_image_is_disk(): mbr = Mbr(self.image_path) mbr.restore_from_file(self.target_device) dlm = DiskLayoutManager(self.image_path) dlm.restore_from_file(disk) self._print_informations(total_bytes, image_name) progress = Progress(total_blocks) progress.start() partitions = information.get_partitions() for p in partitions: if information.get_image_is_disk(): partition = disk.get_partition_by_number(p.number, p.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, p.type) if partition is None: raise ErrorRestoringImage("No valid partitions found") if p.uuid is not None: partition.filesystem.open_to_write(p.uuid) else: partition.filesystem.open_to_write() if partition.filesystem.is_swap(): continue file_name = FILE_PATTERN % (image_name, p.number) with open(self.image_path + file_name, 'rb') as f: # TODO: Work with parallelism while True: # Ugly header = f.read(compressor.get_header_size()) if not len(header): break size = compressor.read_block_header(header) cdata = f.read(size) data = compressor.extract(cdata) partition.filesystem.write(data) progress.increment(1) partition.filesystem.close() progress.stop() print "completed."