path: root/lib/isodumper.py

# coding:utf-8

# !/usr/bin/env python3
#
#  Copyright (c) 2007-2009 Canonical Ltd.
#
#  Author: Oliver Grawert <ogra@ubuntu.com>
#
#  Modifications 2013 from papoteur <papoteur@mageialinux-online.org>
#  and Geiger David <david.david@mageialinux-online.org>
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License as
#  published by the Free Software Foundation; either version 2 of the
#  License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software Foundation,
#  Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.

#  Requires python3-parted


import sys
import importlib
try:
    from isodumper import version
except:
    import version


###########
# imports #
###########
import yui
import time

import os
import re
import gettext
from subprocess import Popen, PIPE
from pydbus import SystemBus

import logging
import threading
from gi.repository import GLib
from queue import SimpleQueue
import psutil
import manatools.args as args


class NoUDisks2(Exception):
    pass


class UDisks2(object):
    BLOCK = 'org.freedesktop.UDisks2.Block'
    DRIVE = 'org.freedesktop.UDisks2.Drive'
    SERVICE = 'org.freedesktop.UDisks2'

    def __init__(self):
        self.bus = SystemBus()
        try:
            self.iface = self.bus.get(self.SERVICE)
        except:
            raise NoUDisks2()
        self._udisks2_obj_manager = self.iface["org.freedesktop.DBus.ObjectManager"]

    def find_devices(self):
        objects = self._udisks2_obj_manager.GetManagedObjects()
        re_drive = re.compile("(?P<path>.*?/drives/(?P<id>.*))")
        re_block = re.compile("(?P<path>.*?/block_devices/(?P<id>.*))")
        devs = [m.groupdict() for m in
                [re_drive.match(path) for path in (objects.keys())]
                if m]
        blocks = [m.groupdict() for m in
                  [re_block.match(path) for path in (objects.keys())]
                  if m]
        list = []

        for block in blocks:
            if not (self.SERVICE + '.Partition' in objects[block['path']]):  # we skip partition blocks
                for dev in devs:
                    if dev['path'] == objects[block['path']][self.BLOCK]['Drive']:
                        # we look for device which is referenced in Drive attribute of the current block
                        dev_obj = objects[dev['path']][self.DRIVE]
                        if (dev_obj['ConnectionBus'] == 'usb' or dev_obj['ConnectionBus'] == 'sdio') and \
                                (dev_obj['Removable'] == 1 or dev_obj[
                                    'MediaRemovable'] == 1):  # we keep only blocks where device ConnectionBus is sdio or usb
                            item = []
                            vend = dev_obj['Vendor']
                            if vend == "":
                                name = dev_obj['Model']
                            else:
                                name = vend + " " + dev_obj['Model']
                            path = '/dev/' + block['path'].split('/')[-1]
                            size = dev_obj['Size']
                            item.append(name)
                            item.append(path)
                            item.append(size)
                            list.append(item)
        return list

    def do_unmount(self, target):
        # keep only the end, like sdb
        target = os.path.basename(target)
        objects = self._udisks2_obj_manager.GetManagedObjects()
        re_block = re.compile('(?P<path>.*?/block_devices/(?P<id>.*))')
        blocks = [m.groupdict() for m in
                  [re_block.match(path) for path in (objects.keys())]
                  if m]
        for block in blocks:
            if (self.SERVICE + '.Partition' in objects[block['path']]):  # we skip non partition blocks
                # Table should be something like '/org/freedesktop/UDisks2/block_devices/sdb'
                if objects[block['path']][self.SERVICE + '.Partition']['Table'].split('/')[-1] == target:
                    if (self.SERVICE + '.Encrypted' in objects[block['path']]):  # Is the partition encrypted ?
                        path_to_encrypted = objects[block['path']][self.SERVICE + '.Encrypted']['CleartextDevice']
                        if path_to_encrypted != '/':
                            iface = self.bus.get(self.SERVICE, path_to_encrypted)
                            fs = iface[self.SERVICE + '.Filesystem']
                            if fs.MountPoints:  # partition is mounted
                                fs.Unmount({})
                            iface = self.bus.get(self.SERVICE, block['path'])
                            fs = iface[self.SERVICE + '.Encrypted']
                            fs.Lock({})
                            logging.debug(f"Unmounting encryted {block['path']}")
                    else:
                        iface = self.bus.get(self.SERVICE, block['path'])
                        if self.SERVICE + '.Filesystem' in  objects[block['path']]:
                            fs = iface[self.SERVICE + '.Filesystem']
                            if fs.MountPoints:  # partition is mounted
                                logging.debug(f"Unmounting {block['path']}")
                                fs.Unmount({})
                            else:
                                logging.debug(f"Not mounted {block['path']}")
        return True, ""

    def eject(self, device):
        ''' device is expected like /dev/sda'''
        block = os.path.basename(device)
        iface = self.bus.get(self.SERVICE, '/org/freedesktop/UDisks2/block_devices/' + block)
        drive = iface.Get(self.BLOCK, "Drive")
        i_drive = self.bus.get(self.SERVICE, drive)
        i_drive.Eject({})


class Info(object):
    def __init__(self, title, richtext, text):
        self.title = title
        self.richtext = richtext
        self.text = text


class ParseCLI(args.AppArgs):
    def __init(self, command):
        super().__init__(command)


class IsoDumper(object):

    def get_devices(self, selected=None):
        self.list = self.u.find_devices()
        while len(self.list) == 0:
            if self.nodevDialog():
                self.list = self.u.find_devices()
            else:
                return False
        self.devicelist.addItem("", False)
        if len(self.list) > 0:
            for name, path, size in self.list:
                if size != 0:
                    label = str(name + ' (' + path.lstrip() + ') ' + self.sizeof_fmt(size))
                    sel = (label == selected) if selected else False
                    self.devicelist.addItem(label, sel)                    
            return True

    def udev_wait(self, operation):
        wait = Popen(["udevadm", "settle", "--timeout=15"], stderr=PIPE)
        wait.communicate()
        working = True
        while working:
            time.sleep(0.5)
            wait.poll()
            rc = wait.returncode
            if not (rc is None):
                wait = None
                working = False
        if rc != 0:
            self.return_state = False
            self.return_message = _("Timeout reached when {}".format(operation))
            return False
        return True

    def update_list(self):
        self.devicelist.deleteAllItems()
        self.get_devices()
        self.img_name = ""
        self.ima.setLabel(self.ChooseImage)
        self.backup_select.setLabel(self.ChooseImage)
        self.dialog.recalcLayout()
        self.restore()

    def update_list_on_event(self):
        selitem = self.devicelist.selectedItem().label()
        self.devicelist.deleteAllItems()
        self.get_devices(selected = selitem)
        if self.devicelist.selectedItem().label() != selitem:
            self.restore()
        self.dialog.recalcLayout()

    def device_selected(self):
        selitem = self.devicelist.selectedItem()
        if selitem is not None:
            self.dev = selitem.label()
            for name, path, size in self.list:
                if self.dev.startswith(name + ' (' + path.lstrip()):
                    self.deviceSize = size
                    self.device_name = name.rstrip().replace(' ', '')
                    self.logger(_('Target Device: ') + self.dev)
                    self.formatbt.setEnabled()
                    self.ima.setEnabled()
                    self.backup_select.setEnabled()
                    break

    @staticmethod
    def sizeof_fmt(num):
        # I18N these are units for files size
        for unit in [_('B'), _('KiB'), _('MiB'), _('GiB'), _('TiB')]:
            if abs(num) < 1024.0:
                return "%3.3f %s" % (num, unit)
            num /= 1024.0
        return "%.1f %s" % (num, _('TiB'))

    def backup_choosed(self):
        # Add .img if not specified
        if not self.backup_img_name.lower().endswith('.img'):
            self.backup_img_name = self.backup_img_name + ".img"
        head, tail = os.path.split(self.backup_img_name)
        self.backup_dest = self.backup_img_name
        self.backup_select.setLabel(tail)
        self.dialog.recalcLayout()
        self.backupbt.setEnabled()

    def do_format(self, format_type, name):
        target = self.dev.split('(')[1].split(')')[0]
        info = Info(_("Formatting confirmation"), True, self.warning)
        if self.ask_YesOrNo(info):
            rc = self.raw_format(target, format_type, name)
            self.operation = False
            if rc == 0:
                message = _('The device was formatted successfully.')
                self.logger(message)
                self.success()
            elif rc == 5:
                message = _("An error occurred while creating a partition.")
                self.logger(message)
                self.emergency(message)
            elif rc == 127:
                message = _('Authentication error.')
                self.logger(message)
                self.emergency(message)
            else:
                message = _('An error occurred.')
                self.emergency(message)

    def restore(self):
        self.backup_select.setDisabled()
        self.backupbt.setDisabled()
        self.formatbt.setDisabled()
        self.ima.setDisabled()
        self.writebt.setDisabled()
        self.devicelist.setEnabled()
        self.progress.setLabel(_("Progress"))
        self.progress.setValue(0)
        self.progress.setDisabled()
        self.refreshbt.setEnabled()
        self.persistencecb.setChecked(False)
        self.persistencecb.setDisabled()
        self.cryptcb.setChecked(False)
        self.cryptcb.setDisabled()
        self.cryptkey.setDisabled()

    def onProgress(self, frac):
        self.logger(_('Wrote: {}% '.format(frac)))
        self.progress.setValue(frac)
        self.dialog.pollEvent()

    def raw_format(self, usb_path, fstype, label):
        self.u.do_unmount(usb_path)
        self.udev_wait(_("unmounting"))
        self.operation = True
        if os.geteuid() > 0:
            launcher = 'pkexec'
            self.process = Popen(
                [launcher, '/usr/bin/python3', '-u', '/usr/lib/isodumper/raw_format.py', '-d', usb_path, '-f', fstype,
                 '-l', label, '-u', str(os.geteuid()), '-g', str(os.getgid())], shell=False, stdout=PIPE,
                preexec_fn=os.setsid)
        else:
            self.process = Popen(
                ['/usr/bin/python3', '-u', '/usr/lib/isodumper/raw_format.py', '-d', usb_path, '-f', fstype, '-l',
                 label, '-u', str(os.geteuid()), '-g', str(os.getgid())], shell=False, stdout=PIPE,
                preexec_fn=os.setsid)
        working = True
        while working:
            time.sleep(0.5)
            self.process.poll()
            rc = self.process.returncode
            if rc is None:
                working = True
            else:
                self.process = None
                working = False
        return rc

    def backup_go(self):
        dest = self.backup_img_name
        if os.path.exists(dest):
            info = Info(_("Backup confirmation"), True, _("Do you want to overwrite the file?"))
            if not (self.ask_YesOrNo(info)):
                self.returncode = 1
                return True
        st = os.statvfs(os.path.dirname(dest))
        free = st.f_bavail * st.f_frsize
        if free < self.deviceSize:
            sizeM = str(self.deviceSize / (1024 * 1024))
            message = _("The destination directory is too small to receive the backup (%s Mb needed)") % (sizeM)
            self.logger(message)
            self.emergency(message)
        else:
            self.returncode = 0
            source = self.dev.split('(')[1].split(')')[0]
            self.logger(_('Backup to:') + ' ' + dest)
            bus = SystemBus()
            iface = bus.get("org.mageia.Magiback", "Isodumper")
            # Writing step
            iface.do_write(source, dest, self.deviceSize)
            while not iface.done:
                progress = iface.progress
                self.progress.setValue(progress)
                self.dialog.pollEvent()
                time.sleep(.2)
            success, message = iface.end()
            if success:
                self.logger(
                    _('{source} successfully written to {target}').format(source=source.split('/')[-1], target=dest))
                self.progress.setEnabled()
                self.progress.setValue(100)
                self.dialog.pollEvent()
                self.logger(message)
                self.success()
            else:
                self.emergency(message)

    def do_write(self):
        self.writebt.setDisabled()
        self.devicelist.setDisabled()
        self.formatbt.setDisabled()
        self.backupbt.setDisabled()
        self.backup_select.setDisabled()
        self.progress.setEnabled()
        source = self.img_name
        target = self.dev.split('(')[1].split(')')[0]
        b = os.path.getsize(source)
        if b > (self.deviceSize):
            message = _('The device is too small to contain the ISO file.')
            self.logger(message)
            self.emergency(message)
        else:
            info = Info(_("Writing confirmation"), True, self.warning)
            if self.ask_YesOrNo(info):
                if self.deviceSize > 1024 * 1024 * 1024 * 32:
                    info = Info(_("Warning"), True,
                                _('The device is bigger than 32 Gbytes. Are you sure you want use it?'))
                    if self.ask_YesOrNo(info):
                        pass
                    else:
                        return
                self.ima.setDisabled()
                self.writebt.setDisabled()
                self.progress.setLabel(_('Writing {source} to {target}').format(source=source.split('/')[-1],
                                                                                target=target.split('/')[-1]))
                self.logger(_('Executing copy from ') + source + _(' to ') + target)
                bus = SystemBus()
                iface = bus.get("org.mageia.Magiback", "Isodumper")
                success, message = self.u.do_unmount(target)
                self.udev_wait(_("unmounting"))
                if success:
                    # Writing step
                    iface.do_write(source, target, b)
                    iface.get_sum(source)
                    progress = iface.progress
                    while not iface.done:
                        progress = iface.progress
                        self.progress.setValue(progress)
                        self.dialog.pollEvent()
                        time.sleep(.5)
                    success, message = iface.end()
                    if success:
                        self.logger(
                            _('Image {source} successfully written to {target}').format(source=source.split('/')[-1],
                                                                                        target=target))
                        self.logger(_('Bytes written: ') + str(b))
                        self.progress.setLabel(_('Checking ') + target.split('/')[-1])
                        self.progress.setValue(0)
                        self.dialog.pollEvent()
                        # Checking
                        iface.check_write(target, source)
                        progress = 0
                        while progress < 100:
                            self.progress.setValue(progress)
                            self.dialog.pollEvent()
                            time.sleep(.5)
                            progress = iface.progress
                        nowarning, message = iface.end()
                        self.progress.setEnabled()
                        self.logger(message)
                        # Add persistent partition if asked
                        if self.persistencecb.isChecked():
                            self.progress.setLabel(_("Adding persistent partition"))
                            self.progress.setValue(0)
                            if self.cryptcb.isChecked():
                                if self.cryptkey.value() == "":
                                    self.logger(
                                        _("No key for encrypted partition provided. Adding the partition aborted."))
                                else:
                                    iface.do_persistence(target, "mgalive-persist", self.cryptkey.value())
                                    while not iface.done:
                                        progress = iface.progress
                                        self.progress.setValue(progress)
                                        self.progress.setLabel(iface.message)
                                        self.dialog.pollEvent()
                                        time.sleep(.5)
                                    if iface.state:
                                        self.logger(_("Added encrypted persistent partition"))
                                    else:
                                        self.logger(_("Adding encrypted persistent partition failed"))
                                        self.logger(iface.message)
                                        nowarning = False
                            else:
                                iface.do_persistence(target, "mgalive-persist", "")
                                while not iface.done:
                                    progress = iface.progress
                                    self.progress.setValue(progress)
                                    self.dialog.pollEvent()
                                    time.sleep(.5)
                                if iface.state:
                                    self.logger(_("Added persistent partition"))
                                else:
                                    self.logger(_("Adding persistent partition failed"))
                                    self.logger(iface.message)
                                    nowarning = False
                        # Unmount if partitions are automatically mounted and then eject
                        self.progress.setValue(100)
                        self.dialog.pollEvent()
                        success, message = self.u.do_unmount(target)
                        self.udev_wait(_("unmounting"))
                        if success:
                            self.u.eject(target)
                            if nowarning :
                                self.success()
                            else:
                                self.warn()
                        else:
                            self.emergency(message)
                            self.restore()
                    else:
                        self.emergency(message)
                else:
                    self.emergency(message)
                    self.restore()
            else:
                self.restore()

    def success(self):
        self.operation = False
        self.final_unsensitive()
        info = Info(_("Success"), True, _("The operation completed successfully.\n\
 You are free to unplug it now, a logfile \n\
(/home/-user- or /root)/.isodumper/isodumper.log will be saved when\n\
 you close the application."))
        if self.ask_OK(info):
            return

    def warn(self):
        self.operation = False
        self.final_unsensitive()
        info = Info(_("Warning"), True, _("The operation completed, but with anomalies.\n\
 Check carefully the messages in log view.\n\
 You are free to unplug it now, a logfile \n\
(/home/-user- or /root)/.isodumper/isodumper.log will be saved when\n\
 you close the application."))
        if self.ask_OK(info):
            return
    def confirm_close(self, *args):
        if not self.operation:  # no writing , backup nor format running
            self.close()
        else:  # writing , backup or format running
            info = Info(_("Warning"), True, _("Writing is in progress. Exiting during writing \n\
            will make the device or the backup unusable.\n\
            Are you sure you want to quit during writing?"))
            if self.ask_YesOrNo(info):
                return True
            else:
                return False

    def emergency(self, message):
        self.operation = False
        self.returncode = 1
        self.final_unsensitive()
        info = Info(_("Error"), True, message)
        self.ask_OK(info)

    def final_unsensitive(self):
        self.ima.setDisabled()
        self.devicelist.setDisabled()
        self.writebt.setDisabled()
        self.progress.setDisabled()
        self.backup_select.setDisabled()
        self.persistencecb.setDisabled()

    def wip_unsensitive(self):
        self.ima.setDisabled()
        self.devicelist.setDisabled()
        self.writebt.setDisabled()
        self.backup_select.setDisabled()
        self.backupbt.setDisabled()
        self.refreshbt.setDisabled()
        self.persistencecb.setDisabled()

    def close(self):
        self.write_logfile()
        self.dialog.destroy()
        self.dialog = None
        if yui.YUI.app().isTextMode():
            self.glib_loop.quit()
            self.glib_thread.join()

    def write_logfile(self):
        logpath = os.path.join(os.path.expanduser('~'), '.isodumper')
        if not (os.path.isdir(logpath)):
            os.mkdir(logpath)
        logfile = open(logpath + '/isodumper.log', "w", encoding="utf-8")
        logfile.write(self.logview.logText())
        logfile.close()

        print((self.logview.logText()))

    def logger(self, text):
        self.logview.appendLines(text + "\n")

    def activate_devicelist(self):
        self.devicelist.setEnabled()
        self.logger(_('Image ') + ": " + self.img_name)

    #        self.chooser.set_tooltip_text(self.img_name)

    def help_dialog(self):
        info = Info(_("IsoDumper"), True, _("Mageia IsoDumper") + "<BR />\
----------------<BR />" +
                    _("This GUI program is primarily for safely writing a bootable ISO image to a USB flash drive, \
an operation devious & potentially hazardous when done by hand. As a bonus, it can also back up the \
entire previous contents of the flash drive onto the hard disc, and restore the flash drive \
to its previous state subsequently.") + "<BR />" +
                    _("It gives also a feature for formatting the USB device.") + "<BR /><BR />" +
                    _(
                        "IsoDumper can be launched either from the menus, or a user console with the command 'isodumper'.") + "<BR />" +
                    _(
                        "The root password is solicited when this is necessary for the program's operation.") + " <BR />" +
                    _("The flash drive can be inserted beforehand or once the program is started. In the latter case, a \
dialogue will say that there is no flash drive inserted, and allow a 'retry' to find it once it is. <BR />\
(You may have to close any automatically opened File Manager window).") + "<BR /><BR />" +
                    _("The fields of the main window are as follows:<BR />\
- Device to work on: the device of the USB flash drive, a drop-down list to choose from.<BR />\
- Write Image: to choose the source ISO image *.iso (or flash drive backup file *.img) to write out.<BR />\
- Write to device: This button launches the operation - with a prior warning dialogue.") + "<BR />" +
                    _(
                        "- Add a persistent partition: the remaining space will be used in a new partition where data from the Live system can be written and recovered between sessions.") + "<BR />" +
                    _(
                        "- Encrypt: the persistent partition will be encrypted with the key provided in <i>Key</i> field.") + "<BR />" +
                    _("The operation is shown in the progress bar beneath.") + "<BR />" +
                    _("- Backup to: define the name and placement of the backup image file. The current flash drive \
will be backed up to a disc file. Note that the entire flash drive is preserved, regardless of its \
actual contents; ensure that you have the necessary free disc space (the same size as the USB device). \
This backup file can be used later to restore the flash drive by selecting it as the source *.img file to write out.") + "<BR />" +
                    _("- Backup the device: launch the backup operation.") + "<BR />" +
                    _("- Format the device: create an unique partition on the entire volume in the specified format in FAT, \
exFAT, NTFS or ext. You can specify a volume name and the format in a new dialog box.") + "<BR />")
        if self.ask_OK(info):
            return

    def __init__(self, debug=False):
        APP = "isodumper"
        DIR = "/usr/share/locale"
        # Call translation catalog
        gettext.install(APP, localedir=DIR, names=('ngettext',))

        # Check that there is no other instance running
        current_pid = psutil.Process().pid
        proc_iter = psutil.process_iter(attrs=["pid", "name"])
        for p in proc_iter:
            if (p.info["name"] == APP) and (p.info["pid"] != current_pid):
                info = Info(_("Error"), True, _("There is another instance of Isodumper already running."))
                self.ask_OK(info)
                yui.YUILoader.deleteUI()
                exit()

        # TODO Read log level from command line
        level = logging.DEBUG if debug else logging.ERROR
        logpath = os.path.join(os.path.expanduser('~'), '.isodumper')
        if not (os.path.isdir(logpath)):
            os.mkdir(logpath)
        logging.basicConfig(filename=os.path.join(logpath,"isodumper2.log"),
                            format='%(asctime)s %(levelname)-8s %(message)s',
                            level=level)

        # define size of the selected device
        self.deviceSize = 0

        # Operation running
        self.operation = False

        self.ChooseImage = _("Choose an image")
        self.warning = _("Warning\nThis will destroy all data on the target device,\n\
        are you sure you want to proceed?\n\
        If you say ok here, please <b>do not unplug</b>\
        the device during the following operation.")
        """
        Init/Constructor for the 'widgets'
        """
        yui.YUI.app().setApplicationTitle(_("IsoDumper") + " " + version.RELEASE)
        yui.YUI.app().setApplicationIcon("/usr/share/icons/isodumper.png")
        self.atelier = yui.YUI.widgetFactory()
        self.dialog = self.atelier.createPopupDialog()
        # create the main gui
        # +---+-----------------+
        # +   banner            +
        # +---+-----------------+
        # |  devicelist         |
        # +---+-----+------+----+
        # + L | ima | writebt |
        # +---+-----+------+----+
        # + L | backup_select | backupbt |
        # +---+-----+------+----+
        # + F       | formatbt  |
        # +----------------+----+
        # | progress            |
        # +---------------------+
        # | report              |
        # +---------------------+
        # | refreshbt | aboutbt  | helpbt | quitbt  |
        # +---------------------+
        self.ancrage = self.atelier.createReplacePoint(self.dialog)
        self.box = self.atelier.createVBox(self.ancrage)
        self.bannerbox = self.atelier.createHBox(self.box)
        self.banner = self.atelier.createImage(self.bannerbox, "/usr/share/isodumper/header.svg")
        self.devicebox = self.atelier.createHBox(self.box)
        self.devicelist = self.atelier.createComboBox(self.devicebox, _("Device to work on:"), False)
        self.devicelist.setNotify()
        self.devicelist.setStretchable(0, True)
        self.writebox = self.atelier.createHBox(self.box)
        self.atelier.createLabel(self.writebox, _("Write Image:"))
        #   add file picker for image file
        self.ima = self.atelier.createPushButton(self.writebox, self.ChooseImage)
        self.ima.setStretchable(0, True)
        self.ima.setDisabled()
        self.atelier.createHStretch(self.writebox)
        self.writebt = self.atelier.createPushButton(self.writebox, _("&Write to device"))
        self.writebt.setDisabled()
        self.persistencebox = self.atelier.createHBox(self.box)
        self.persistencecol1 = self.atelier.createVBox(self.persistencebox)
        self.persistencecol2 = self.atelier.createVBox(self.persistencebox)
        self.persistencecb = self.atelier.createCheckBox(self.persistencecol1,
                                                         _("Add a persistent partition in the remaining space"))
        self.persistencebox2 = self.atelier.createHBox(self.box)
        self.cryptcb = self.atelier.createCheckBox(self.persistencecol1, _("Encrypt partition"))
        self.cryptkey = self.atelier.createInputField(self.persistencecol2, _("Key:"), passwordMode=True)
        self.persistencecb.setDisabled()
        self.persistencecb.setNotify()
        self.cryptcb.setDisabled()
        self.cryptcb.setNotify()
        self.cryptkey.setDisabled()
        self.backupbox = self.atelier.createHBox(self.box)
        self.atelier.createLabel(self.backupbox, _("Backup to:"))
        #   add file picker for backup file name
        self.backup_select = self.atelier.createPushButton(self.backupbox, self.ChooseImage)
        self.backup_select.setStretchable(0, True)
        self.backup_select.setDisabled()
        self.atelier.createHStretch(self.backupbox)
        self.backupbt = self.atelier.createPushButton(self.backupbox, _("Backup the device"))
        self.backupbt.setDisabled()
        self.formatbox = self.atelier.createHBox(self.box)
        self.atelier.createLabel(self.formatbox, _("Format the device in FAT, exFAT, NTFS or ext:"))
        self.atelier.createHStretch(self.formatbox)
        self.formatbt = self.atelier.createPushButton(self.formatbox, _("Format the device"))
        self.formatbt.setDisabled()
        self.progressbox = self.atelier.createHBox(self.box)
        self.progress = self.atelier.createProgressBar(self.progressbox, _("Progress"), 100)
        self.progress.setStretchable(0, True)
        self.reportbox = self.atelier.createHBox(self.box)
        self.reportbox.setWeight(1, 30)
        self.logview = self.atelier.createLogView(self.reportbox, _("Report"), 10)
        self.logview.setStretchable(0, True)
        self.buttonsbox = self.atelier.createHBox(self.box)
        self.refreshbt = self.atelier.createPushButton(self.devicebox, _("Refresh"))
        self.refreshbt.setStretchable(0, True)
        self.aboutbt = self.atelier.createPushButton(self.buttonsbox, _("About"))
        self.aboutbt.setStretchable(0, True)
        self.helpbt = self.atelier.createPushButton(self.buttonsbox, _("Help"))
        self.helpbt.setStretchable(0, True)
        self.quitbt = self.atelier.createPushButton(self.buttonsbox, _("Quit"))
        self.quitbt.setStretchable(0, True)
        self.u = None
        try:
            self.u = UDisks2()
        except:
            message = _('UDisks2 is not available on your system')
            self.logger(message)
            self.emergency(message)
        if not self.get_devices():
            self.dialog.destroy()
            yui.YUILoader.deleteUI()
            exit()
        self.device_selected()
        self.dialog.recalcLayout()
        self.ancrage.showChild()
        self.uEventQueue = SimpleQueue()
        if yui.YUI.app().isTextMode():
            self.glib_loop = GLib.MainLoop()
            self.glib_thread = threading.Thread(target=self.glib_mainloop, args=(self.glib_loop,))
            self.glib_thread.start()

        self.u.iface["org.freedesktop.DBus.ObjectManager"].InterfacesAdded.connect(self.device_changed)
        self.u.iface["org.freedesktop.DBus.ObjectManager"].InterfacesRemoved.connect(self.device_changed)

    def glib_mainloop(self, loop):
        '''
        thread function for glib main loop
        '''
        loop.run()


    def device_changed(self, a, b):
        self.uEventQueue.put({'event': "device-changed", 'value': True})
        
    def ask_format(self):
        atelier = yui.YUI.widgetFactory()
        dialog = atelier.createPopupDialog()
        vb = atelier.createVBox(dialog)
        label = atelier.createInputField(vb, _("Label for the device:"))
        cr = atelier.createRadioButtonGroup(vb)
        vb_c = atelier.createVBox(cr)
        vb_c1 = atelier.createHBox(vb_c)
        format_fat = atelier.createRadioButton(atelier.createLeft(vb_c1), _("FAT 32 (Windows)"))
        vb_c4 = atelier.createHBox(vb_c)
        format_exfat = atelier.createRadioButton(atelier.createLeft(vb_c4), _("exFAT (Windows)"))
        vb_c2 = atelier.createHBox(vb_c)
        format_ntfs = atelier.createRadioButton(atelier.createLeft(vb_c2), _("NTFS (Windows)"))
        vb_c3 = atelier.createHBox(vb_c)
        format_ext = atelier.createRadioButton(atelier.createLeft(vb_c3), _("ext4 (Linux)"))
        bb = atelier.createHBox(vb)
        executebt = atelier.createPushButton(bb, _("Execute"))
        cancelbt = atelier.createPushButton(bb, _("Cancel"))
        dialog.open()
        returncode = True
        while True:
            event = dialog.waitForEvent()
            if event.eventType() == yui.YEvent.CancelEvent:
                returncode = False
                break
            if event.widget() == executebt:
                if format_fat.value():
                    format_type = 'fat32'
                    format_label = label.value().upper()[:11]
                    break
                if format_exfat.value():
                    format_type = 'exfat'
                    format_label = label.value()[:32]
                    break
                if format_ntfs.value():
                    format_type = 'ntfs'
                    format_label = label.value()[:32]
                    break
                if format_ext.value():
                    format_type = 'ext4'
                    format_label = label.value()
                    break
            if event.widget() == cancelbt:
                returncode = False
                break
        dialog.destroy()
        if returncode:
            return True, format_type, format_label
        else:
            return False, " ", " "

    def ask_OK(self, info):
        yui.YUI.widgetFactory
        mgafactory = yui.YMGAWidgetFactory.getYMGAWidgetFactory(yui.YExternalWidgets.externalWidgetFactory("mga"))
        dlg = mgafactory.createDialogBox(yui.YMGAMessageBox.B_ONE)
        dlg.setTitle(info.title)
        dlg.setText(info.text, info.richtext)
        dlg.setButtonLabel(_("OK"), yui.YMGAMessageBox.B_ONE)
        dlg.setMinSize(60, 10)
        return dlg.show() == yui.YMGAMessageBox.B_ONE

    def ask_YesOrNo(self, info):
        yui.YUI.widgetFactory
        mgafactory = yui.YMGAWidgetFactory.getYMGAWidgetFactory(yui.YExternalWidgets.externalWidgetFactory("mga"))
        dlg = mgafactory.createDialogBox(yui.YMGAMessageBox.B_TWO)
        dlg.setTitle(info.title)
        dlg.setText(info.text, info.richtext)
        dlg.setButtonLabel(_("Yes"), yui.YMGAMessageBox.B_ONE)
        dlg.setButtonLabel(_("No"), yui.YMGAMessageBox.B_TWO)
        dlg.setMinSize(60, 8)
        return dlg.show() == yui.YMGAMessageBox.B_ONE

    def aboutDialog(self):
        yui.YUI.widgetFactory
        mgafactory = yui.YMGAWidgetFactory.getYMGAWidgetFactory(yui.YExternalWidgets.externalWidgetFactory("mga"))
        dlg = mgafactory.createAboutDialog("Isodumper", version.RELEASE, "GPLv2",
                                           _("Oliver Grawert<BR />Papoteur<BR />Pictures : Timothée Giet"), _(
                "A tool for writing ISO images to  a device") + "<BR />http://gitweb.mageia.org/software/isodumper", "")
        dlg.show()

    def nodevDialog(self):
        yui.YUI.widgetFactory
        mgafactory = yui.YMGAWidgetFactory.getYMGAWidgetFactory(yui.YExternalWidgets.externalWidgetFactory("mga"))
        dlg = mgafactory.createDialogBox(yui.YMGAMessageBox.B_TWO)
        dlg.setTitle("IsoDumper")
        dlg.setText(_(
            "Warning\nNo target devices were found.\nYou need to plug in a USB Key to which the image can be written."))
        dlg.setButtonLabel(_("Refresh"), yui.YMGAMessageBox.B_ONE)
        dlg.setButtonLabel(_("Cancel"), yui.YMGAMessageBox.B_TWO)
        dlg.setMinSize(60, 8)
        return dlg.show() == yui.YMGAMessageBox.B_ONE

    def handleevent(self):
        self.traitement = None
        while True:
            event = self.dialog.waitForEvent(100)
            if event.eventType() == yui.YEvent.CancelEvent:
                self.close()
                break
            if event.widget() == self.quitbt:
                self.close()
                break
            if event.widget() == self.ima:
                self.img_name = yui.YUI.app().askForExistingFile("", "*.iso *.img", self.ChooseImage)
                if self.img_name != "":
                    self.ima.setLabel(os.path.basename(self.img_name))
                    self.dialog.recalcLayout()
                    self.writebt.setEnabled()
                    self.activate_devicelist()
                    self.persistencecb.setEnabled()
            if event.widget() == self.persistencecb:
                print(self.persistencecb.value)
                if self.persistencecb.isChecked():
                    self.cryptcb.setEnabled()
                else:
                    self.cryptcb.setDisabled()
                    self.cryptkey.setDisabled()
                    self.cryptcb.setChecked(False)
            if event.widget() == self.cryptcb:
                if self.cryptcb.isChecked():
                    self.cryptkey.setEnabled()
                else:
                    self.cryptkey.setDisabled()
            if event.widget() == self.writebt:
                self.wip_unsensitive()
                self.do_write()
                self.restore()
            if event.widget() == self.backupbt:
                self.wip_unsensitive()
                self.backup_go()
                self.restore()
            if event.widget() == self.backup_select:
                self.backup_img_name = yui.YUI.app().askForSaveFileName("", "*.img", _("Backup to:"))
                if self.backup_img_name != '':
                    self.backup_choosed()
            if event.widget() == self.formatbt:
                code, format_type, name = self.ask_format()
                if code:
                    self.do_format(format_type, name)
                    self.restore()
            if event.widget() == self.devicelist:
                self.device_selected()
            try:
                if event.widget() == self.refreshbt:
                    self.update_list()
            except:
                pass
            try:
                if event.widget() == self.helpbt:
                    self.help_dialog()
            except:
                pass
            try:
                if event.widget() == self.quitbt:
                    self.confirm_close()
            except:
                pass
            if event.widget() == self.aboutbt:
                self.aboutDialog()
            try:
                item = self.uEventQueue.get_nowait()
                if item['event'] == "device-changed":
                    self.update_list_on_event()
            except Exception as e:
                pass

    def run(self):
        try:
            self.handleevent()
        except Exception:
            import traceback
            traceback.print_exc()
            yui.YDialog.deleteAllDialogs()


if __name__ == "__main__":
    # Send the yui logging outside of the console
    log = yui.YUILog.setLogFileName("/dev/null")
    parser = ParseCLI('isodumper')
    parser.parser.add_argument('--debug', help=_('allow debug information'), action='store_true')
    if parser.args.version:
        print(version.RELEASE)
    else:
        if parser.args.debug:
            app = IsoDumper(debug=True)
        else:
            app = IsoDumper()
        app.run()
        # next line seems to be a workaround to prevent the qt-app from crashing
        # see https://github.com/libyui/libyui-qt/issues/41
        yui.YUILoader.deleteUI()