def rc_update (self, clobberSwitch=False) :
        """effects: do our part of rc update"""
        if not os.path.isdir (self.dir()) :
            return
        svninfo = SvnInfoSvn (None, self.dir())
        self = self.useSvnuser (svninfo.svnuser())
        self = self.resolveTags ()

        if self.tag() != svninfo.tag() :
            cmd = ["svn", "switch", self.m_url]
            if not clobberSwitch :
                status = "\n" + self.svn_status()
                if status.find ("\nM") != -1 or status.find ("\nC") != -1:
                    print "you currently have changes in package " + self.name()
                    print "either check them in, or switch versions manually using:"
                    print "  cd " + self.dir()
                    print "  " + " ".join(cmd)
                    #print "  " + string.join (cmd, " ")
                    return
                pass
            print "switching " + self.name() + " to " + self.tag()
            shell_exec (cmd, workDir=self.dir(), retries=2, noReturn=True)
            return

        if os.path.basename (os.path.dirname (self.m_url)) == "tags" :
            print "package " + self.name() + " already at version " + self.tag()
            return

        print "updating " + svninfo.name() + " from head"
        shell_exec (["svn", "update"], workDir=self.dir(), retries=2, noReturn=True)
        return

    def step_mount_partitions(self, setup):
        self.step_mount_source(setup)

        # Mount the target partition
        for partition in setup.partitions:
            if(partition.mount_as is not None and partition.mount_as != ""):
                  if partition.mount_as == "/":
                        self.update_progress(total=4, current=3, message=_("Mounting %(partition)s on %(mountpoint)s") % {'partition':partition.partition.path, 'mountpoint':"/target/"})
                        print " ------ Mounting partition %s on %s" % (partition.partition.path, "/target/")
                        if partition.type == "fat32":
                            fs = "vfat"
                        else:
                            fs = partition.type
                        self.do_mount(partition.partition.path, "/target", fs, None)
                        break

        # Mount the other partitions
        for partition in setup.partitions:
            if(partition.mount_as is not None and partition.mount_as != "" and partition.mount_as != "/" and partition.mount_as != "swap"):
                print " ------ Mounting %s on %s" % (partition.partition.path, "/target" + partition.mount_as)
                shell_exec("mkdir -p /target" + partition.mount_as)
                if partition.type == "fat16" or partition.type == "fat32":
                    fs = "vfat"
                else:
                    fs = partition.type
                self.do_mount(partition.partition.path, "/target" + partition.mount_as, fs, None)

def manually_edit_partitions():
    """ Edit only known disks in gparted, selected one first """
    model, itr = installer.go("treeview_disks").get_selection().get_selected()
    preferred = model[itr][-1] if itr else ''  # prefer disk currently selected and show it first in gparted
    disks = ' '.join(sorted((disk for disk, desc, sdd, detachable in installer.setup.disks), key=lambda disk: disk != preferred))
    shell_exec('umount -f ' + disks)  # umount disks (if possible) so gparted works out-of-the-box
    shell_exec('gparted {} &'.format(disks))

    def root_conf(self):
        """effects: determine the root parameters used for compilation
        returns: the path to the configuration file generated
        failures: incompatible root installation"""
        if not self.m_root_conf:
            file = os.path.join(self.bin(), "root_config_" + self.arch())
            ROOTSYS = os.getenv("ROOTSYS")
            if ROOTSYS == None:
                if os.path.isfile(file):
                    ROOTSYS = get_field(file, "ROOTSYS")
                    if ROOTSYS and ROOTSYS != "":
                        raise RCError("no valid root version found, try setting up root using\n" +
                                      "  source " + ROOTSYS + "/bin/thisroot.sh")
                if os.path.isdir("/cvmfs/atlas.cern.ch/repo/ATLASLocalRootBase"):
                    raise RCError("no valid root version found, try setting up root using\n" +
                                  "  export ATLAS_LOCAL_ROOT_BASE=/cvmfs/atlas.cern.ch/repo/ATLASLocalRootBase\n" +
                                  "  source ${ATLAS_LOCAL_ROOT_BASE}/user/atlasLocalSetup.sh\n" +
                                  "  localSetupROOT")
                if shell_exec(["which", "root-config"], allowFail=True) != "":
                    raise RCError("no valid root version found, try setting up root using\n" +
                                  "  source `root-config --prefix`/bin/thisroot.sh")
                raise RCError("no valid root version found, please set up root")

            if os.path.isfile(file):
                myrootversion = get_field(file, "ROOT_VERSION")
                if not myrootversion:
                    set_field(file, "ROOT_VERSION", self.root_version())
                elif self.root_version() != myrootversion:
                    myrootsys = get_field(file, "ROOTSYS")
                    raise RCError("Root Version: " + self.root_version() + "\n" +
                                  "is not the same as previous version:\n" +
                                  "   " + myrootversion + "\n" +
                                  "either set up the correct root version e.g. via:\n" +
                                  "  source " + myrootsys + "/bin/thisroot.sh\n" +
                                  "or clean out the old object files via:\n" +
                                  "  rc clean")
                self.m_root_conf = file
                return file

            myarch = shell_exec(["root-config", "--etcdir"]) + "/Makefile.arch"
            if not os.path.isfile(myarch):
                myarch = os.getenv("ROOTSYS") + "/share/doc/root/test/Makefile.arch"
            if not os.path.isfile(myarch):
                shell_args = ["find", os.getenv("ROOTSYS") + "/.",
                              "-name", "Makefile.arch"]
                search = shell_exec(shell_args).strip().split("\n")
                if len(search) > 0:
                    myarch = search[0]
            if not os.path.isfile(myarch):
                raise RCError("failed to find Makefile.arch in " + os.getenv("ROOTSYS"))

            with open(file + "-", "w") as f:
                shell_args = ["make", "-f", self.dir() + "/Makefile-print",
                              "MAKEFILE_ARCH=" + myarch]
                rc = shell_exec(shell_args, stdout=f, returnRC=True)
            if rc != 0:
                raise RCError("could not determine compilation parameters")
            os.rename(file + "-", file)
            self.m_root_conf = file
        return self.m_root_conf

 def svn_cp_tags (self, tag, message):
     """effects: copy this url to the tags directory, as in 'svn cp
     -m >message< >url< >base_url</tags/>tag<'"""
     shell_exec (["svn", "cp", "-m", message, self.m_base + "/trunk",
                  self.m_base + "/tags/" + tag], noReturn=True,
                 retries=2)
     pass

 def copySource (self, target) :
     """effects: copy our source directory to the source directory
     of the target"""
     if self.srcdir() == target.srcdir():
         print "using " + self.name() + " source from release"
         pass
     else:
         print "copying " + self.name() + " source"
         ignore = [".svn", "*~"]
         if self.name() == "RootCore":
             ignore += ["bin", "include", "obj", "rootcore_config",
                        "root_config_*", "load_packages_info_*",
                        "load_packages_success", "data", "lib", "python",
                        "user_scripts"]
             pass
         rel_dir = self.m_wa.relPath (target.m_wa.area(), self.srcdir(), self.srcdir())
         if rel_dir[0] != "/" and rel_dir != ".":
             ignore.append (os.path.basename (rel_dir))
             pass
         if rel_dir != ".":
             shutil.copytree (self.srcdir(), target.srcdir(), symlinks = True,
                              ignore = shutil.ignore_patterns (*ignore))
             shell_exec (["chmod", "-R", "u+rw", target.srcdir()])
             pass
         pass
     pass

 def mount_device(self, device_path):
     # Check if mounted
     mount_point = get_mount_point(device_path)
     if mount_point == '':
         mount_point = TMP_MOUNTPOINT
         #print((">> mount %s ro on %s" % (device_path, mount_point)))
         shell_exec('mount --read-only {} {}'.format(device_path, mount_point))
     return mount_point

 def svn_commit (self, message):
     """effects: commit this package, as with 'svn commit -m
     >message<'"""
     if not self.dir() :
         raise Exception ("no directory associated with the url")
     shell_exec (["git", "commit", "-a", "-m", message], workDir=self.m_dir,
                 noReturn=True)
     pass

def do_mount(device, mountpoint, filesystem=None, options=None):
    if get_mount_point(device, mountpoint) == '':
        if options:
            if options[0:1] != '-':
                options = '-o ' + options
        else:
            options = ''
        filesystem = '-t ' + filesystem if filesystem else ''
        cmd = "mount {options} {filesystem} {device} {mountpoint}".format(**locals())
        shell_exec(cmd)

    def stop(self):
        """Stops vm. Destroys changes on it """
        if self.destroy_on_exit:
            if self.started:
                if self.use_libvirt:                
                    self.vm.destroy()
                else:
                    shell_exec('lxc-stop -n "{0}"'.format(self.lxc_name))

            self.fs.umount()
            shell_exec('rm -rf "{0}"'.format(self.fs.mpoint))

    def create_snapshot(self):
        self.snapname = str(uuid.uuid1())
        self.snappath = os.path.join(self.mpoint, "snapshots", self.snapname)

        shell_exec('btrfs subvolume snapshot "{0}" "{1}"'.format(self.mpoint, self.mpoint))

        for subvolid, subvolume in self.subvolumes():
            if subvolume.endswith(self.snapname):
                break

        assert subvolume.endswith(self.snapname)
        self.subvolid = subvolid

 def on_btnDelete_clicked(self, widget):
     selected_isos = self.tvUsbIsosHandler.getToggledValues(toggleColNr=0, valueColNr=2)
     if selected_isos:
         msg =  _("Are you sure you want to remove the selected ISO from the device?")
         answer = QuestionDialog(self.btnDelete.get_label(), msg)
         if answer:
             for iso in selected_isos:
                 iso_path = join(self.device["mount"], iso)
                 if exists(iso_path):
                     os.remove(iso_path)
                     self.log.write("Remove ISO: {}".format(iso_path))
             shell_exec("usb-creator -d {} -g".format(self.device["path"]))
             self.on_cmbDevice_changed()
             self.fill_treeview_usbcreator(self.device["mount"])

 def rc_checkout (self, shared=False) :
     """effects: do our part of rc checkout"""
     if os.path.isdir (self.dir()) :
         return
     print "checking out " + self.name()
     mkdir_p (os.path.dirname (self.dir()))
     if not self.m_url :
         raise RCError ("can not run rc checkout without git url")
     cmd = ["git", "clone"]
     if shared :
         cmd += ["--shared"]
         pass
     cmd += [self.m_url, self.dir()]
     shell_exec (cmd, noReturn=True)
     pass

 def addPkgDep(self, name, required, caller, cycle, catalog, allowMiss, wa):
     if self.getPkg(name):
         return
     for pkg in cycle:
         if name == pkg:
             raise Exception("cyclical dependence involving packages: " +
                             string.join(cycle))
     pkg = catalog.getPkg(name)
     if not pkg:
         if allowMiss or not required:
             return
         message = ""
         if caller:
             message = "package " + name + " not known, required by " + caller
         else:
             message = "package " + name + " not known"
         shell_args = ["grep", "/" + name + "/tags", wa.dir() + "/all_packages"]
         known = shell_exec(shell_args, allowFail=True).split("\n")
         while len(known) > 0 and known[len(known) - 1] == "":
             known.remove("")
         if len(known) > 0:
             message += "\ntry checking it out with"
             for pkg in known:
                 message += "\n  rc checkout_pkg " + pkg
         raise RCError(message)
     for dep in pkg.harddep():
         addPkgDep(self, dep, True, name, cycle + [name], catalog, allowMiss, wa)
     for dep in pkg.trydep():
         addPkgDep(self, dep, False, name, cycle + [name], catalog, allowMiss, wa)
     self.addPkg(pkg)

 def svn_status (self, noReturn=False, update=False, allowNone=False):
     """effects: same as 'svn status'
     returns: the status (unless noReturn is specified)"""
     if update:
         raise RCError ("-u not supported for git status")
     return shell_exec (["git", "status", "-s"], workDir=self.m_dir,
                        noReturn=noReturn)

 def getLibFlags (self, lib, user=False, external=False):
     """returns: the linker flags to use when linking a library
     depending on all the packages in the list"""
     result = ""
     if not user and not external:
         result = str(result + " " +
                      get_field (self.m_wa.root_conf(), "SOFLAGS")).strip()
         #result = string.strip (result + " " + get_field (self.m_wa.root_conf(), "SOFLAGS"))
         pass
     result = str(result + " " +
                  shell_exec (["root-config", "--ldflags"])).strip()
     #result = string.strip (result + " " + shell_exec (["root-config", "--ldflags"]))
     for var in ["LDFLAGS", "CPPEXFLAGS"]:
         flags = os.getenv (var)
         if flags and flags != "":
             result = str(result + " " + flags).strip()
             pass
         pass
     if not user:
         result += " " + get_field (self.m_wa.root_conf(), "ROOTLIBS")
         pass
     if (not user and not external and
         get_field (self.m_wa.root_conf(), "PLATFORM") == "macosx"):
         result = str(result + " -dynamiclib -undefined dynamic_lookup" +
                      " -install_name @rpath/" +
                      os.path.basename (lib)).strip()
         #result = string.strip (result + " -dynamiclib -undefined dynamic_lookup -install_name @rpath/" + os.path.basename (lib))
         pass
     return result;

    def linkPostcompile (self) :
        """effects: link all the files created during compilation"""
        if self.name() == "RootCore":
            return

        ROOTCORECONFIG = self.m_wa.arch()

        #for file in "lib" + self.name() + ".so", "lib" + self.name() + "_Reflex.so", "lib" + self.name() + "_Reflex.rootmap", self.name() + "CINT_rdict.pcm", self.name() + "_Reflex_rdict.pcm":
        for file in ("lib" + self.name() + ".so",
                     "lib" + self.name() + "_Reflex.so",
                     "lib" + self.name() + "_Reflex.rootmap",
                     self.name() + "CINT_rdict.pcm",
                     self.name() + "_Reflex_rdict.pcm"):
            source = os.path.join (self.libdir(), file)
            if os.path.isfile (source):
                self.m_wa.lnRel (source, os.path.join (self.m_wa.bin(), "lib",
                                                       ROOTCORECONFIG, file))
                pass
            pass

        dir = self.bindir()
        if os.path.isdir (dir):
            for file in os.listdir (dir):
                self.m_wa.lnRel (os.path.join (dir, file),
                                 os.path.join (self.m_wa.bin(), "bin",
                                               ROOTCORECONFIG, file))
                pass
            pass

        file = os.path.join (self.srcdir(), "cmt", "link.RootCore")
        if os.path.isfile (file):
            if not os.access (file, os.X_OK):
                raise RCError ("execute flag not set on " +
                               os.path.basename (file) +
                               ", please run\n  chmod +x " + file);
            newEnv = {}
            newEnv["ROOTCORECMT"] = self.libdir()
            newEnv["ROOTCOREBIN"] = self.m_wa.bin()
            newEnv["ROOTCOREOBJ"] = self.m_wa.obj()
            shell_exec ([file], workDir=os.path.join (self.srcdir(), "cmt"),
                        noReturn=True, newEnv=newEnv)
            pass
        pass

    def root_version(self):
        """description: the root version description string.

        rationale: this is mostly used to check that we call 'rc
        clean' whenever we change root version"""
        if not hasattr(self, "m_root_version"):
            try:
                root_version = shell_exec(["root", "-b", "-q"])
                index = root_version.find("\nROOT")
                if index == -1:
                    raise RCError("failed to read root version, please send me the output of\nroot -b -q")
                root_version = root_version[index+1:]
                index = root_version.find("\n")
                if index == -1:
                    raise RCError("failed to read root version, please send me the output of\nroot -b -q")
                self.m_root_version = root_version[0:index]
            except RCError:
                self.m_root_version = shell_exec(["root-config", "--version"]).rstrip()
        return self.m_root_version

 def svn_ls_tags (self):
     """returns: a list of tags as in 'svn ls >base-svn</tags'"""
     result = []
     shell_args = ["svn", "ls", self.m_base + "/tags"]
     #for tag in string.split (shell_exec (["svn", "ls", self.m_base + "/tags"], retries=2)) :
     for tag in shell_exec (shell_args, retries=2).split():
         result.append (tag.strip("/"))
         #result.append(string.strip(tag, "/"))
         pass
     return sorted (result)

 def step_format_partitions(self, setup):        
     for partition in setup.partitions:                    
         if(partition.format_as is not None and partition.format_as != ""):                
             # report it. should grab the total count of filesystems to be formatted ..
             self.update_progress(total=4, current=1, pulse=True, message=_("Formatting %(partition)s as %(format)s ..." % {'partition':partition.partition.path, 'format':partition.format_as}))
             
             #Format it
             if partition.format_as == "swap":
                 cmd = "mkswap %s" % partition.partition.path
             else:
                 if (partition.format_as == "jfs"):
                     cmd = "mkfs.%s -q %s" % (partition.format_as, partition.partition.path)
                 elif (partition.format_as == "xfs"):
                     cmd = "mkfs.%s -f %s" % (partition.format_as, partition.partition.path)
                 elif (partition.format_as == "vfat"):
                     cmd = "mkfs.%s %s -F 32" % (partition.format_as, partition.partition.path)
                 else:
                     cmd = "mkfs.%s %s" % (partition.format_as, partition.partition.path) # works with bfs, btrfs, ext2, ext3, ext4, minix, msdos, ntfs, vfat
             shell_exec(cmd)
             partition.type = partition.format_as