path: root/build_tools/larch8/larch0/gui/controller.py

#!/usr/bin/env python2
#
# controller.py - Manages file-system access and calling of larch scripts
#
# (c) Copyright 2010 Michael Towers (larch42 at googlemail dot com)
#
# This file is part of the larch project.
#
#    larch 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.
#
#    larch 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 larch; if not, write to the Free Software Foundation, Inc.,
#    51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#
#----------------------------------------------------------------------------
#2010.10.25

import sys, os, __builtin__
from liblarch.rootrun import init_rootrun
import threading
from glob import glob
from subprocess import call
try:
    import json as serialize
except:
    import simplejson as serialize

from config import *

from liblarch.translation import i18n_module, lang, i18nurl
__builtin__._ = i18n_module(base_dir, 'larch')
__builtin__.lang = lang


exports = {}
def add_exports(elist):
    for key, method in elist:
        exports[key] = method

__builtin__.add_exports = add_exports


def error0(message):
    sys.stderr.write('>>ERROR>>' + message + '\n')
    sys.stderr.flush()
__builtin__.error0 = error0


class Fs:
    """Collect file system access methods in one class.
    """
    def __init__(self):
        add_exports(    (
                ('fetch_layout', self.fetch_layout),
                ('isfile', self.isfile),
                ('isdir', self.isdir),
                ('rm_rf', self.rm_rf),
                ('get_partitions', self.get_partitions),
                ('readfile', self.readfile),
                ('savefile', self.savefile),
                ('get_docs_url', self.get_docs_url),
                ('oldsqf', self.oldsqf),
                ('oldlocales', self.oldlocales),
                ('browse', self.browse))
        )

    def fetch_layout(self, layout_file):
        fh = open(base_dir + '/gui/layouts/' + layout_file)
        r = fh.read()
        fh.close()
        return (True, eval(r))

    def rm_rf(self, path):
        call(['rm', '-rf', self._getpath(path)])
        return (True, None)

    def oldsqf(self):
        return (True,
                os.path.isfile(self._getpath('install:' + CHROOT_SYSTEMSQF))
                or os.path.isfile(self._getpath('install:' + CHROOT_DIR_MEDIUM
                        + '/larch/system.sqf')))

    def oldlocales(self):
        return (True, os.path.isdir(self._getpath('install:%s/locale'
                % CHROOT_DIR_BUILD)))

    def isfile(self, path):
        return (True, os.path.isfile(self._getpath(path)))

    def isdir(self, path):
        return (True, os.path.isdir(self._getpath(path)))


    def browse(self, path):
        fpath = self._getpath(path)
        if call(['mkdir', '-p', fpath]) == 0:
            # Start file browser at fpath
            call(project_manager.appget('filebrowser').replace('$', fpath)
                    + ' &', shell=True)
            return (True, None)
        else:
            return (False, None)

    def readfile(self, f):
        f = self._getpath(f)
        try:
            fh = open(f)
            r = fh.read()
            fh.close()
            return (True, r)
        except:
            return (False, _("Couldn't read file '%s'") % f)

    def savefile(self, f, d):
        f = self._getpath(f)
        dir = os.path.dirname(f)
        if not os.path.isdir(dir):
            os.makedirs(dir)
        try:
            fh = open(f, "w")
            fh.write(d)
            fh.close()
            return (True, None)
        except:
            return (False, _("Couldn't save file '%s'") % f)

    def _getpath(self, f):
        if f[0] != "/":
            base, f = f.split(':')
            f = '/' + f
            if base == 'base':
                f = base_dir + f
            elif base == 'profile':
                f = project_manager.profile_path + f
            elif base == 'working':
                f = project_manager.project_dir + f
            else:
                f = project_manager.get_ipath()[1] + f
        return f

    def get_docs_url(self, page):
        return (True, i18nurl(base_dir + '/docs/html/' + page))


    def get_partitions(self):
        """Get a list of available (not too small) partitions.
        """
        partlist = []
        with open('/proc/partitions') as fh:
            for l in fh:
                fields = l.split()
                if len(fields) == 4:
                    dev = fields[3]
                    if dev.startswith('sd') and (dev[-1] in '0123456789'):
                        size = (int(fields[2]) + 512) / 1024
                        if (size > 200):
                            # Keep a tuple (partition, size in MiB)
                            partlist.append(('/dev/' + dev, size))
        return (True, partlist)



class LarchScripts:
    """This class deals with calling the larch scripts.
    As they must be run as root, the rootrun module is used, which uses
    pexpect to start the subprocesses with su or sudo.
    Callbacks are used to fetch the password and return output lines
    (as they become available) and also to signal completion.
    While reading output from the subprocess the gui must remain responsive,
    and capable of updates (e.g. for logging, or cancelling of the process).
    To achieve this a separate thread is used for reading input from the
    subprocess (this is also taken care of by the rootrun module).
    The output lines and completion information are passed to the gui
    via signals/messages. The gui is responsible for handling them in the
    correct thread, e.g. by adding 'idle' calls.
    """
    def __init__(self):
        """Initialize the mechanism for making root calls.
        """
        self.rootfunc = init_rootrun(self._pwget)


    def do(self, cmdname, *args):
        """This is the larchscripts dispatcher.
        The first argument is the name of the function, the remaining ones
        are the arguments to the function.
        """
        return getattr(self, 'l_' + cmdname)(*args)


    def _pwget(self, cb, prompt):
        """Callback to fetch password, running in rootrun thread.
        """
        self.pw_event = threading.Event()
        ui_signal('get_password', prompt)
        self.pw_event.wait()
        self.rootfunc.cb_done(cb, *self.pw_returned)


    def l_sendpassword(self, ok, pw):
        """The gui passes in the password via this call.
        The result needs to be passed to the waiting self._pwget method
        (which is running in a different thread).
        """
        self.pw_returned = (ok, pw)
        self.pw_event.set()
        return None


    def _line_cb(self, cb, line):
        try:
            dline = serialize.loads(line)
        except:
            dline = line
        ui_signal('line_cb', dline)


    def _end_cb(self, cb, ok, res):
        # As the output is passed line-by-line there is no need to pass
        # it again.
        ui_signal('end_cb', ok)


    def call(self, cmd, arg=[]):
        """Start a process running as root.
        """
        args = ' '.join(['"%s"' % i for i in arg])
        cmdx = '%s/cli/%s.py -s %s' % (base_dir, cmd, args)
        self.l_rootfn(cmdx)
        return None


    def l_rootfn(self, cmd):
        """Run a command as root.
        """
        ui_signal('log', '++' + cmd)
        self.rootfunc.run(cmd, self._end_cb, self._line_cb, project_manager.project_dir)
        return None


    def l_archin(self, cmd, installrepos):
        args = ['-p', project_manager.profile_path,
                '-i', project_manager.get_ipath()[1],
                '-c', project_manager.get('pacman_cache')]
        rf = project_manager.project_dir + '/pacman.conf.repos'
        if installrepos and os.path.isfile(rf):
            args += ['-r', rf]
        return self.call('archin', args + cmd.split())


    def l_larchify(self, oldsyssqf, oldlocales):
        args = ['-p', project_manager.profile_path,
                '-i', project_manager.get_ipath()[1],]
        if oldsyssqf:
            args.append('-o')
        if oldlocales:
            args.append('-l')
        return self.call('larchify', args)


    def l_larchmedium(self, dev):
        return self.call('medium', ['-T', '-S', dev,])


    def l_writemedium(self, source, args):
        if source:
            args += ['-S', source]
        else:
            args += ['-p', project_manager.profile_path]
            args += ['-i', project_manager.get_ipath()[1]]
        return self.call('medium', args)


    def l_pid(self, pid):
        self.rootfunc.setpid(pid)
        return None


    def l_interrupt(self):
        ui_signal('log', '--Terminate--')
        self.rootfunc.interrupt()
        return None


    def l_reply(self, reply):
        self.rootfunc.send(reply)
        return None


    def l_close(self):
        # if something is running, stop it ...
        try:
            self.rootfunc.interrupt()
        except:
            pass

fs = Fs()

import project
project_manager.init()

larchscripts = LarchScripts()
add_exports((   ('larchscript', larchscripts.do),
    ))