~xubuntu-dev/ubiquity/lp1437180_feh

#!/usr/bin/python

 

import os

import sys

import subprocess

import time

import signal

import errno

import imp

 

sys.path.insert(0, '/usr/lib/ubiquity')

 

import ubiquity.frontend

 

background = '/usr/share/backgrounds/warty-final-ubuntu.png'

 

class XStartupError(EnvironmentError):

    pass

 

class DM:

    def __init__(self, vt, display):

        self.vt = vt

        self.display = display

        self.server_started = False

 

        # Look for a frontend module; we won't actually use it (yet), but

        # this lets us find out which window manager etc. to launch. Be

        # careful that importing this here will cause the underlying library

        # to try to talk to the X server, which won't go well.

        frontend_names = ['gtk_ui', 'kde_ui']

        self.frontend = None

        for f in frontend_names:

            try:

                imp.find_module(f, ubiquity.frontend.__path__)

                self.frontend = f

                break

            except ImportError:

                pass

        else:

            raise AttributeError, ('No frontend available; tried %s' %

                                   ', '.join(frontend_names))

 

    def sigusr1_handler(self, signum, frame):

        self.server_started = True

 

    def server_preexec(self):

        signal.signal(signal.SIGUSR1, signal.SIG_IGN)

 

    def run(self, *program):

        null = open('/dev/null', 'w')

        if not os.path.exists('/var/log/installer'):

            os.makedirs('/var/log/installer')

        logfile = open('/var/log/installer/dm', 'w')

 

        signal.signal(signal.SIGUSR1, self.sigusr1_handler)

        signal.signal(signal.SIGTTIN, signal.SIG_IGN)

        signal.signal(signal.SIGTTOU, signal.SIG_IGN)

        server = subprocess.Popen(['X', '-br', '-ac', '-noreset', self.vt, self.display], stdin=null, stdout=logfile, stderr=logfile, preexec_fn=self.server_preexec)

 

        os.environ['DISPLAY'] = self.display

 

        # Really we should select on a pipe or something, but it's not worth

        # the effort for now.

        timeout = 60

        while not self.server_started:

            if timeout == 0:

                raise XStartupError, "X server failed to start after 60 seconds"

            time.sleep(1)

            timeout -= 1

 

        if self.frontend == 'gtk_ui':

            if os.access(background, os.R_OK):

                import gtk

                pixbuf = gtk.gdk.pixbuf_new_from_file(background)

                root = gtk.gdk.get_default_root_window()

                (root_width, root_height) = root.get_size()

                scaled = pixbuf.scale_simple(root_width, root_height, gtk.gdk.INTERP_BILINEAR)

                (pixmap, mask) = scaled.render_pixmap_and_mask(0)

                root.set_back_pixmap(pixmap, False)

                root.clear()

                gtk.gdk.flush()

 

        if self.frontend == 'gtk_ui':

            wm = subprocess.Popen(['/usr/bin/metacity', '--sm-disable'], stdin=null, stdout=logfile, stderr=logfile)

        elif self.frontend == 'kde_ui':

            wm = subprocess.Popen('/usr/bin/kwin', stdin=null, stdout=logfile, stderr=logfile)

 

        greeter = subprocess.Popen(program, stdin=null, stdout=logfile, stderr=logfile)

        ret = greeter.wait()

 

        def sigalrm_handler(signum, frame):

            os.kill(wm.pid, signal.SIGKILL)

 

        os.kill(wm.pid, signal.SIGTERM)

        signal.signal(signal.SIGALRM, sigalrm_handler)

        signal.alarm(1) # low patience with WMs failing to exit on demand

        while True:

            try:

                wm.wait()

            except OSError, e:

                if e.errno == errno.EINTR:

                    continue

                raise

            break

        signal.alarm(0)

        os.kill(server.pid, signal.SIGTERM)

        server.wait()

 

        if ret is not None and ret >= 0:

            return ret

        else:

            return 1

 

if len(sys.argv) < 3:

    sys.stderr.write('Usage: ubiquity-dm <vt[1-N]> <:[0-N]> <program> [<arguments>]\n')

    sys.exit(1)

 

vt, display = sys.argv[1:3]

dm = DM(vt, display)

sys.exit(dm.run(*sys.argv[3:]))