def get_version(cls):
        """Gets version of program -> version

        Looks for version in the following places (by order):
        1) <INSTALL_PATH>/version.txt (if it exists)
        2) debian/changelog (if it exists - parsed with dpkg-parsechangelog)
        3) `autoversion HEAD`
        """
        
        version_file = join(cls.INSTALL_PATH, "version.txt")

        if lexists(version_file):
            return file(version_file).readline().strip()

        orig_cwd = os.getcwd()

        if cls.INSTALL_PATH:
            os.chdir(cls.INSTALL_PATH)
            
        try:
            if not exists("debian/changelog"):
                output = getoutput("autoversion HEAD")
                version = output
            else:
                output = getoutput("dpkg-parsechangelog")
                version = [ line.split(" ")[1]
                            for line in output.split("\n")
                            if line.startswith("Version:") ][0]
        except ExecError:
            os.chdir(orig_cwd)
            return "?"

        os.chdir(orig_cwd)
        return version

def apply_overlay(src, dst, olist_path):
    orig_cwd = os.getcwd()
    os.chdir(src)
    executil.getoutput("tar --create --files-from=%s | tar --extract --directory %s" % 
                       (olist_path, executil.mkarg(dst)))

    os.chdir(orig_cwd)

    def refresh(self):
        self.uri_release.download()
        self.uri_release_gpg.download()

        executil.getoutput("gpgv", "--keyring", self.chanko.trustedkeys,
                           self.uri_release_gpg.path, self.uri_release.path)

        release_content = file(self.uri_release.path).read()

        for uri_index in self.uri_indexes:
            # skip download if latest
            if self._index_in_release(uri_index.path, release_content):
                continue

            # attempt download of Packages.bz2, fallback to Packages.gz
            try:
                uri_index.download()
            except executil.ExecError, e:
                if uri_index.filename == "Packages.bz2" and not e.exitcode == 22:
                    raise e

                print "* info: Packages.bz2 not available, falling back to gzip..."
                uri_index.url = uri_index.url.replace("bz2", "gz")
                uri_index.download()

            # verify integrity, delete on failure
            if not self._index_in_release(uri_index.path, release_content):
                os.remove(uri_index.path)
                raise Error("verification failed: ", uri_index.path)

    def __init__(self):
        TempFile.__init__(self, prefix='key_')
        os.remove(self.path)

        executil.getoutput("ssh-keygen -N '' -f %s" % self.path)
        os.remove(self.path + ".pub")

        PrivateKey.__init__(self, self.path)

    def _is_alive(self):
        try:
            getoutput("/etc/init.d/postgresql", "status")

        except ExecError, e:
            if e.exitcode == 3:  # ie. stopped
                return False
            else:
                raise Error("Unknown postgresql status exitcode: %s" % e.exitcode)

def _is_signed(fpath, keyring):
    fpath_sig = fpath + ".sig"
    if not exists(fpath_sig):
        return False

    try:
        executil.getoutput("gpg --keyring=%s --verify" % keyring, fpath_sig)
        return True
    except:
        return False

    def start(cls):
        if cls.is_running():
            return

        retries = 2
        for i in range(retries):
            try:
                executil.getoutput(cls.INIT_SCRIPT, "start")
                return
            except executil.ExecError, e:
                pass

    def get_version():
        try:
            if not exists("debian/changelog"):
                return getoutput("autoversion HEAD")

            output = getoutput("dpkg-parsechangelog")
            version = [ line.split(" ")[1]
                        for line in output.split("\n")
                        if line.startswith("Version:") ][0]
            return version

        except ExecError:
            return None

def termcap_get_lines():
    buf = executil.getoutput("resize")
    m = re.search('LINES=(\d+)', buf)
    if not m:
        raise Error("can't parse `resize` output")

    return int(m.group(1))

    def usage(self):
        if self.advanced_enabled:
            default_button_label = "Advanced Menu"
            default_return_value = "advanced"
        else:
            default_button_label = "Quit"
            default_return_value = "quit"

        #if no interfaces at all - display error and go to advanced
        if len(self._get_filtered_ifnames()) == 0:
            error = "No network adapters detected"
            if not self.advanced_enabled:
                fatal(error)

            self.console.msgbox("Error", error)
            return "advanced"

        #if interfaces but no default - display error and go to networking
        ifname = self._get_default_nic()
        if not ifname:
            error = "Networking is not yet configured"
            if not self.advanced_enabled:
                fatal(error)

            self.console.msgbox("Error", error)
            return "networking"

        #tklbam integration
        try:
            tklbam_status = executil.getoutput("tklbam-status --short")
        except executil.ExecError, e:
            if e.exitcode in (10, 11): #not initialized, no backups
                tklbam_status = e.output
            else:
                tklbam_status = ''

 def _get_public_ipaddr(cls):
     publicip_cmd = conf.Conf().publicip_cmd
     if publicip_cmd:
         try:
             return executil.getoutput(publicip_cmd)
         except executil.ExecError, e:
             pass

    def _read_partition_table(path):
        partitions = []
        for line in executil.getoutput("fdisk -l %s" % path).splitlines():
            if line.startswith(path):
                partitions.append(Partition(line))

        return partitions

    def _cmdcache(self, arg, sort=False):
        results = executil.getoutput("apt-cache %s %s" % (self.options, arg))
        if sort:
            results = results.splitlines()
            results.sort()
            results = "\n".join(results)

        return results

def fmt_welcome():
    welcome = "Welcome to %s" % socket.gethostname()
    kernel = executil.getoutput("uname -mr")
    sysversion = fmt_sysversion()
    if sysversion:
        welcome += ", " + sysversion + " (" + kernel + ")"

    return welcome

def list_databases():
    for line in getoutput(su('psql -l')).splitlines():
        m = re.match(r'^ (\S+?)\s', line)
        if not m:
            continue

        name = m.group(1)
        yield name

    def _get_blockdev_path(path):
        p = executil.getoutput("udevadm info -q path -n %s" % path).lstrip('/')
        for path in ( join('/sys', p , 'device'), 
                      join('/sys/block', basename(p)), 
                      join('/dev', basename(p)) ):
            if not exists(path):
                raise Error('usbdev path error: %s' % path)

        return join('/dev', basename(p))

def main():
    print indent(2,fmt_welcome())

    try:
        sysinfo = executil.getoutput("/usr/lib/sysinfo/sysinfo.py")
        print
        print indent(2, sysinfo)
        print
    except executil.ExecError:
        pass

def _get_physdevpath(devname):
    """ugly hack to get the physical device path of first parent"""
    raw_output = executil.getoutput('udevadm info -a -n %s' % devname)

    for line in raw_output.splitlines():
        line = line.strip()
        if line.startswith("looking at parent device '/devices/xen/vbd-"):
            return line.split()[-1].strip(":").strip("'")

    return None

    def from_system(cls):
        try:
            system_version = file("/etc/turnkey_version").readline().strip()
        except:
            try:
                system_version = executil.getoutput("turnkey-version")
            except executil.ExecError:
                return None

        return cls.from_string(system_version)

def get_uris(chanko, cache, packages, nodeps=False):
    try:
        cmd = "apt-get %s --print-uris -y install" % (cache.options)
        raw = executil.getoutput(cmd, *packages)
    except executil.ExecError, e:
        if re.search("Couldn\'t find package", e[2]):
            print "Couldn't find package '%s'" % e[2].split()[-1]
            return []
        else:
            raise Error("get_uris raised error: ", e)