def expand_diskimage(self, associated_task=None):
     # TODO: might use -p to get percentage to feed into progress.
     root = join_path(self.info.disks_dir, 'root.disk')
     resize2fs = join_path(self.info.bin_dir, 'resize2fs.exe')
     resize_cmd = [resize2fs, '-f', root,
                   '%dM' % self.info.root_size_mb]
     run_command(resize_cmd)

 def modify_bootini(self, drive, associated_task):
     log.debug("modify_bootini %s" % drive.path)
     bootini = join_path(drive.path, 'boot.ini')
     if not os.path.isfile(bootini):
         log.debug("Could not find boot.ini %s" % bootini)
         return
     src = join_path(self.info.root_dir, 'winboot', 'wubildr')
     dest = join_path(drive.path, 'wubildr')
     shutil.copyfile(src,  dest)
     src = join_path(self.info.root_dir, 'winboot', 'wubildr.mbr')
     dest = join_path(drive.path, 'wubildr.mbr')
     shutil.copyfile(src,  dest)
     run_command(['attrib', '-R', '-S', '-H', bootini])
     boot_line = 'C:\wubildr.mbr = "%s"' % self.info.distro.name
     old_line = boot_line[:boot_line.index("=")].strip().lower()
     # ConfigParser gets confused by the ':' and changes the options order
     content = read_file(bootini)
     if content[-1] != '\n':
         content += '\n'
     lines = content.split('\n')
     is_section = False
     for i,line in enumerate(lines):
         if line.strip().lower() == "[operating systems]":
             is_section = True
         elif line.strip().startswith("["):
             is_section = False
         if is_section and line.strip().lower().startswith(old_line):
             lines[i] = boot_line
             break
         if is_section and not line.strip():
             lines.insert(i, boot_line)
             break
     content = '\n'.join(lines)
     write_file(bootini, content)
     run_command(['attrib', '+R', '+S', '+H', bootini])

    def modify_configsys(self, drive, associated_task):
        log.debug("modify_configsys %s" % drive.path)
        configsys = join_path(drive.path, 'config.sys')
        if not os.path.isfile(configsys):
            return
        src = join_path(self.info.root_dir, 'winboot', 'wubildr.exe')
        dest = join_path(drive.path, 'wubildr.exe')
        shutil.copyfile(src,  dest)
        run_command(['attrib', '-R', '-S', '-H', configsys])
        config = read_file(configsys)
        if 'REM WUBI MENU START\n' in config:
            log.debug("Configsys has already been modified")
            return

        config += '''
        REM WUBI MENU START
        [menu]
        menucolor=15,0
        menuitem=windows,Windows
        menuitem=wubildr,$distro
        menudefault=windows,10
        [wubildr]
        device=wubildr.exe
        [windows]

        REM WUBI MENU END
        '''
        write_file(configsys, config)
        run_command(['attrib', '+R', '+S', '+H', configsys])

 def undo_bcd(self, associated_task):
     bcdedit = join_path(os.getenv('SystemDrive'), 'bcdedit.exe')
     if not isfile(bcdedit):
         bcdedit = join_path(os.getenv('SystemRoot'), 'sysnative', 'bcdedit.exe')
     if not os.path.isfile(bcdedit):
         bcdedit = join_path(os.environ['systemroot'], 'System32', 'bcdedit.exe')
     if not os.path.isfile(bcdedit):
         log.error("Cannot find bcdedit")
         return
     id = registry.get_value(
         'HKEY_LOCAL_MACHINE',
         self.info.registry_key,
         'VistaBootDrive')
     if not id:
         log.debug("Could not find bcd id")
         return
     log.debug("Removing bcd entry %s" % id)
     command = [bcdedit, '/delete', id , '/f']
     try:
         run_command(command)
         registry.set_value(
             'HKEY_LOCAL_MACHINE',
             self.info.registry_key,
             'VistaBootDrive',
             "")
     except Exception, err: #this shouldn't be fatal
         log.error(err)

 def select_target_dir(self):
     target_dir = join_path(self.info.target_drive.path, self.info.distro.installation_dir)
     target_dir.replace(' ', '_')
     target_dir.replace('__', '_')
     if os.path.exists(target_dir):
         raise Exception("Cannot install into %s.\nThere is another file or directory with this name.\nPlease remove it before continuing." % target_dir)
     self.info.target_dir = target_dir
     log.info('Installing into %s' % target_dir)
     self.info.icon = join_path(self.info.target_dir, self.info.distro.name + '.ico')

 def uncompress_files(self, associated_task):
     if self.info.target_drive.is_fat():
         return
     command1 = ['compact', join_path(self.info.install_boot_dir), '/U', '/A', '/F']
     command2 = ['compact', join_path(self.info.install_boot_dir,'*.*'), '/U', '/A', '/F']
     for command in [command1,command2]:
         log.debug(" ".join(command))
         try:
             run_command(command)
         except Exception, err:
             log.error(err)

    def extract_file_from_iso(self, iso_path, file_path, output_dir=None, overwrite=True):
        '''
        platform specific
        '''
        log.debug("extracting %s from %s" % (file_path, iso_path))
        if not iso_path or not os.path.exists(iso_path):
            raise Exception('Invalid path %s' % iso_path)
        iso_path = abspath(iso_path)
        file_path = os.path.normpath(file_path)
        if not output_dir:
            output_dir = tempfile.gettempdir()
        output_file = join_path(output_dir, os.path.basename(file_path))
        log.debug("output_file === %s" %output_file)

        if os.path.exists(output_file):
            if overwrite:
                os.unlink(output_file)
            else:
                raise Exception('Cannot overwrite %s' % output_file)
        command = [self.info.iso_extractor, 'e', '-i!' + file_path, '-o' + output_dir, iso_path]
        log.debug("command === %s" % command)
        try:
            output = run_command(command)
        except Exception, err:
            log.exception(err)
            output_file = None

    def create_uninstaller(self, associated_task):
        uninstaller_name = 'uninstall.exe'
        uninstaller_name.replace(' ', '_')
        uninstaller_name.replace('__', '_')
        uninstaller_path = join_path(self.info.target_dir, uninstaller_name)

        if self.info.run_task == "cd_boot":
            display_name = self.info.distro.name + _(" LiveCD")
        elif self.info.flag:
            display_name = self.info.distro.name
        else:
            display_name = self.info.distro.name + _(" LiveCD")

        #display_name = self.info.flag and self.info.distro.name or self.info.distro.name + _(" LiveCD")
       
        if os.path.splitext(self.info.original_exe)[-1] == '.exe':
            log.debug('Copying uninstaller %s -> %s' % (self.info.original_exe, uninstaller_path))
            shutil.copyfile(self.info.original_exe, uninstaller_path)
        registry.set_value('HKEY_LOCAL_MACHINE', self.info.registry_key, 'UninstallString', uninstaller_path)
        registry.set_value('HKEY_LOCAL_MACHINE', self.info.registry_key, 'InstallationDir', self.info.target_dir)
        registry.set_value('HKEY_LOCAL_MACHINE', self.info.registry_key, 'DisplayName', display_name)
        registry.set_value('HKEY_LOCAL_MACHINE', self.info.registry_key, 'DisplayIcon', self.info.icon)
        registry.set_value('HKEY_LOCAL_MACHINE', self.info.registry_key, 'DisplayVersion', self.info.version_revision)
        registry.set_value('HKEY_LOCAL_MACHINE', self.info.registry_key, 'Publisher', "www.startos.org")
        registry.set_value('HKEY_LOCAL_MACHINE', self.info.registry_key, 'URLInfoAbout', self.info.distro.website)
        registry.set_value('HKEY_LOCAL_MACHINE', self.info.registry_key, 'HelpLink', self.info.distro.support)

 def create_virtual_disks(self, associated_task):
     self.info.disks_dir
     for disk in ["root", "home", "usr", "swap"]:
         path = join_path(self.info.disks_dir, disk + ".disk")
         size_mb = int(getattr(self.info, disk + "_size_mb"))
         if size_mb:
             create_virtual_disk(path, size_mb)

    def select_target_dir(self):
        target_dir = join_path(self.info.target_drive.path, self.info.distro.installation_dir)
        target_dir.replace(' ', '_')
        target_dir.replace('__', '_')
        gold_target_dir = target_dir
        #if os.path.exists(target_dir):
        #    raise Exception("Cannot install into %s.\nThere is another file or directory with this name.\nPlease remove it before continuing." % target_dir)
        if self.info.run_task == "cd_boot":
            self.info.target_dir = target_dir+"-livecd"
        elif self.info.flag:
            self.info.target_dir = target_dir+"-loop"
        else:
            self.info.target_dir = target_dir+"-livecd"

        #self.info.target_dir = self.info.flag and target_dir+"-loop" or target_dir+"-livecd"
        log.info('Installing into %s' % self.info.target_dir)
        self.info.icon = join_path(self.info.target_dir, self.info.distro.name + '.ico')

 def undo_bootini(self, drive, associated_task):
     log.debug("undo_bootini %s" % drive.path)
     bootini = join_path(drive.path, 'boot.ini')
     if not os.path.isfile(bootini):
         return
     run_command(['attrib', '-R', '-S', '-H', bootini])
     remove_line_in_file(bootini, 'c:\wubildr.mbr', ignore_case=True)
     run_command(['attrib', '+R', '+S', '+H', bootini])

 def copy_installation_files(self, associated_task):
     self.info.custominstall = join_path(self.info.install_dir, 'custom-installation')
     log.debug("custominstall === %s" %self.info.custominstall)
     src = join_path(self.info.data_dir, 'custom-installation')
     dest = self.info.custominstall
     log.debug('Copying %s -> %s' % (src, dest))
     if os.path.exists(dest):
         shutil.rmtree(dest)
     shutil.copytree(src, dest)
     src = join_path(self.info.root_dir, 'winboot')
     if isdir(src): # make runpy will fail otherwise as winboot will not be there
         dest = join_path(self.info.target_dir, 'winboot')
         log.debug('Copying %s -> %s' % (src, dest))
         if os.path.exists(dest):
             shutil.rmtree(dest)   
         shutil.copytree(src, dest)
     dest = join_path(self.info.custominstall, 'hooks', 'failure-command.sh')
     msg=_('The installation failed. Logs have been saved in: %s.' \
         '\n\nNote that in verbose mode, the logs may include the password.' \
         '\n\nThe system will now reboot.')
     msg = msg % join_path(self.info.install_dir, 'installation-logs.zip')
     msg = "msg=\"%s\"" % msg
     msg = str(msg.encode('utf8'))
     replace_line_in_file(dest, 'msg=', msg)
     src = join_path(self.info.image_dir, self.info.distro.name + '.ico')
     dest = self.info.icon
     log.debug('Copying %s -> %s' % (src, dest))
     shutil.copyfile(src, dest)

 def backup_iso(self, associated_task=None):
     if not self.info.backup_iso:
         return
     backup_dir = self.info.previous_target_dir + "-backup"
     install_dir = join_path(self.info.previous_target_dir, "install")
     for f in os.listdir(install_dir):
         f = join_path(install_dir, f)
         if f.endswith('.iso') and os.path.isfile(f) \
         and os.path.getsize(f) > 1000000:
             log.debug("Backing up %s -> %s" % (f, backup_dir))
             if not isdir(backup_dir):
                 if isfile(backup_dir):
                     log.error("The backup directory %s is a file, skipping ISO backup" % backup_dir)
                     #TBD do something more sensible
                     return
                 os.mkdir(backup_dir)
             target_path = join_path(backup_dir, os.path.basename(f))
             shutil.move(f, target_path)

 def get_windows_user_dir(self):
     homedrive = os.getenv('homedrive')
     homepath = os.getenv('homepath')
     user_directory = ""
     if homedrive and homepath:
         user_directory = join_path(homedrive, homepath)
         user_directory = user_directory.decode('ascii', 'ignore')
     log.debug('user_directory=%s' % user_directory)
     return user_directory

 def diskimage_bootloader(self, associated_task=None):
     src = join_path(self.info.root_dir, 'winboot')
     dest = join_path(self.info.target_dir, 'winboot')
     if isdir(src):
         log.debug('Copying %s -> %s' % (src, dest))
         shutil.copytree(src, dest)
     src = join_path(self.info.disks_dir, 'wubildr')
     shutil.copyfile(src, join_path(dest, 'wubildr'))
     # Overwrite the copy that's in root_dir.
     for drive in self.info.drives:
         if drive.type not in ('removable', 'hd'):
             continue
         dest = join_path(drive.path, 'wubildr')
         try:
             shutil.copyfile(src, dest)
         except: # don't need to worry about failure here
             pass
     os.unlink(src)

 def uncompress_target_dir(self, associated_task):
     if self.info.target_drive.is_fat():
         return
     try:
         command = ['compact', self.info.target_dir, '/U', '/A', '/F']
         run_command(command)
         command = ['compact', join_path(self.info.target_dir,'*.*'), '/U', '/A', '/F']
         run_command(command)
     except Exception, err:
         log.error(err)

 def check_EFI(self):
     efi = False
     if self.info.bootloader == 'vista':
         bcdedit = join_path(os.getenv('SystemDrive'), 'bcdedit.exe')
         if not os.path.isfile(bcdedit):
             bcdedit = join_path(os.environ['systemroot'], 'sysnative', 'bcdedit.exe')
         if not os.path.isfile(bcdedit):
             bcdedit = join_path(os.environ['systemroot'], 'System32', 'bcdedit.exe')
         if not os.path.isfile(bcdedit):
             log.error("Cannot find bcdedit")
             return False
         command = [bcdedit, '/enum']
         result = run_command(command)
         result = result.lower()
         if "bootmgfw.efi" in result:
             efi = True
         if "winload.efi" in result:
             efi = True
     log.debug('EFI boot = %s' % efi)
     return efi

 def modify_EFI_folder(self, associated_task,bcdedit):
     command = [bcdedit, '/enum', '{bootmgr}']
     boot_drive = run_command(command)
     if 'partition=' in boot_drive:
         boot_drive = boot_drive[boot_drive.index('partition=')+10:]
     else:
         boot_drive = boot_drive[boot_drive.index('device')+24:]
     boot_drive = boot_drive[:boot_drive.index('\r')]
     log.debug("EFI boot partition %s" % boot_drive)
     # if EFI boot partition is mounted we use it
     if boot_drive[1]==':':
         efi_drive = boot_drive
     else:
         for efi_drive in 'HIJKLMNOPQRSTUVWXYZ':
             drive = Drive(efi_drive)
             if not drive.type:
                 break
         efi_drive = efi_drive + ':'
         log.debug("Temporary EFI drive %s" % efi_drive)
     if efi_drive != boot_drive:
         run_command(['mountvol', efi_drive, '/s'])
     src = join_path(self.info.root_dir, 'winboot','EFI')
     src.replace(' ', '_')
     src.replace('__', '_')
     dest = join_path(efi_drive, 'EFI',self.info.target_dir[3:])
     dest.replace(' ', '_')
     dest.replace('__', '_')
     if not os.path.exists(dest):
         shutil.os.mkdir(dest)
     dest = join_path(dest,'wubildr')
     if os.path.exists(dest):
         shutil.rmtree(dest)        
     log.debug('Copying EFI folder %s -> %s' % (src, dest))
     shutil.copytree(src,  dest)
     if self.get_efi_arch(associated_task,efi_drive)=="ia32":
         efi_path = join_path(dest, 'grubia32.efi')[2:]
     else:
         efi_path = join_path(dest, 'shimx64.efi')[2:]
     if efi_drive != boot_drive:
         run_command(['mountvol', efi_drive, '/d'])
     return efi_path

 def undo_bootloader(self, associated_task):
     winboot_files = ['wubildr', 'wubildr.mbr', 'wubildr.exe']
     self.undo_bcd(associated_task)
     for drive in self.info.drives:
         if drive.type not in ('removable', 'hd'):
             continue
         self.undo_bootini(drive, associated_task)
         self.undo_configsys(drive, associated_task)
         for f in winboot_files:
             f = join_path(drive.path, f)
             if os.path.isfile(f):
                 os.unlink(f)

 def create_virtual_disks(self, associated_task):
     self.info.disks_dir
     for disk in ["root", "home", "usr", "swap"]:
         path = join_path(self.info.disks_dir, disk + ".disk")
         if os.path.isfile(path):
             log.info(" ** loop file %s exists, will not be created ** " % path)
             continue
         if not getattr(self.info, disk + "_size_mb"):
             continue
         size_mb = int(getattr(self.info, disk + "_size_mb"))
         if size_mb:
             log.debug("virtual_disk === %s,size_mb === %s" %(path,size_mb))
             create_virtual_disk(path, size_mb)