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)
