gnome-shell/src/gnome-shell.in

#!/usr/bin/python

import atexit
import optparse
import os
import random
import re
import shutil
import signal
import subprocess
import sys
import tempfile
import termios
import time
import errno
import dbus

def find_cmd (cmd_list):
    """
    Takes a list of command candidates and returns the first one that exists.
    Raises a system exit if none of the commands exist.
    """
    for cmd in cmd_list:
        if os.path.exists(cmd):
            return cmd
    
    raise SystemExit("None of the commands %s exist" % cmd_list)
    
def pidof(command):
    pidof_cmd = find_cmd(["/sbin/pidof", "/bin/pidof", "/usr/bin/pidof"])
    pidof = subprocess.Popen([pidof_cmd, command], stdout=subprocess.PIPE)
    pids = pidof.communicate()[0].split()
    pidof.wait()

    # pidof doesn't have a "current user only" option, so we may have
    # gotten the pids of other users' processes. Fix that.
    for pid in pids:
        try:
            os.kill(int(pid), 0)
            return pid
        except Exception, e:
            pass
    return None

def kill_gnome_panel(pid):
    if options.verbose:
        print "Terminating panel process %s" % pid
    devnull = open("/dev/null", "w")
    subprocess.call(["gdb", "-batch-silent",
                     "-ex", "call panel_session_do_not_restart()",
                     "-ex", "call exit(0)",
                     "-p", pid], stdout=devnull, stderr=devnull)
    devnull.close()

def start_xephyr():
    tmpdir = tempfile.mkdtemp("", "gnome-shell.")
    atexit.register(shutil.rmtree, tmpdir)

    display = ":" + str(random.randint(10, 99))
    xauth_file = os.path.join(tmpdir, "database")

    # Create a random 128-bit key and format it as hex
    f = open("/dev/urandom", "r")
    key = f.read(16)
    f.close()
    hexkey = "".join(("%02x" % ord(byte) for byte in key))

    # Store that in an xauthority file as the key for connecting to our Xephyr
    retcode = subprocess.call(["xauth",
                               "-f", xauth_file,
                               "add", display,  "MIT-MAGIC-COOKIE-1", hexkey])
    if retcode != 0:
        raise RuntimeError("xauth failed")

    # Launch Xephyr
    try:
        xephyr = subprocess.Popen(["Xephyr", display,
                                   "-auth", xauth_file,
                                   "-screen", options.geometry,
                                   "-host-cursor"])
    except OSError, e:
        if e.errno == errno.ENOENT:
            print "Could not find Xephyr."
            sys.exit(1)
        else:
            raise
    os.environ['DISPLAY'] = display
    os.environ['XAUTHORITY'] = xauth_file

    # Wait for server to get going: LAME
    time.sleep(1)

    # Start some windows in our session.
    subprocess.Popen(["xterm", "-geometry", "+30+30"])
    subprocess.Popen(["xlogo", "-geometry", "-0-0"])
    subprocess.Popen(["xeyes", "-geometry", "-0+30"])

    return xephyr;

GLXINFO_RE = re.compile(r"^(\S.*):\s*\n((?:^\s+.*\n)*)", re.MULTILINE)

def _get_glx_extensions():
    """Return a tuple of server, client, and effective GLX extensions"""

    glxinfo = subprocess.Popen(["glxinfo"], stdout=subprocess.PIPE)
    glxinfo_output = glxinfo.communicate()[0]
    glxinfo.wait()

    glxinfo_map = {}
    for m in GLXINFO_RE.finditer(glxinfo_output):
        glxinfo_map[m.group(1)] = m.group(2)

    server_glx_extensions = set(re.split("\s*,\s*", glxinfo_map['server glx extensions'].strip()))
    client_glx_extensions = set(re.split("\s*,\s*", glxinfo_map['client glx extensions'].strip()))
    glx_extensions = set(re.split("\s*,\s*", glxinfo_map['GLX extensions'].strip()))

    return (server_glx_extensions, client_glx_extensions, glx_extensions)

def start_shell():
    bin_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
    if os.path.exists(os.path.join(bin_dir, 'gnome-shell.in')):
        running_from_source_tree = True
        top_dir = os.path.dirname(bin_dir)
        plugin = os.path.join(top_dir, 'src', 'libgnome-shell.la')
        typelib_dir = os.path.join(top_dir, "src")
        js_dir = os.path.join(top_dir, "js")
        data_dir = os.path.join(top_dir, "data")
    else:
        running_from_source_tree = False
        plugin = 'libgnome-shell'
        js_dir = os.path.join('@pkgdatadir@', 'js')

    # Set up environment
    env = dict(os.environ)
    env.update({'GNOME_SHELL_JS'      : '@GJS_JS_DIR@:@GJS_JS_NATIVE_DIR@:' + js_dir,
                'PATH'                : '@MUTTER_BIN_DIR@:' + os.environ.get('PATH', ''),
                'GNOME_DISABLE_CRASH_DIALOG' : '1'})

    if running_from_source_tree:
        env.update({'GNOME_SHELL_DATADIR' : data_dir,
                    'GI_TYPELIB_PATH'     : typelib_dir})

    jhbuild_gconf_source = os.path.join('@sysconfdir@', 'gconf/2/path.jhbuild')
    if os.path.exists(jhbuild_gconf_source):
        env['GCONF_DEFAULT_SOURCE_PATH'] = jhbuild_gconf_source

    # Work around Ubuntu xulrunner bug,
    # http://bugzilla.gnome.org/show_bug.cgi?id=573413
    pkgconfig = subprocess.Popen(['pkg-config', '--variable=sdkdir', 'mozilla-js'],
                                 stdout=subprocess.PIPE)
    mozjs_sdkdir = pkgconfig.communicate()[0].strip()
    pkgconfig.wait()
    if pkgconfig.returncode == 0:
        mozjs_libdir = re.sub('-(sdk|devel)', '', mozjs_sdkdir)
        if os.path.exists(mozjs_libdir + '/libmozjs.so'):
            env['LD_LIBRARY_PATH'] = os.environ.get('LD_LIBRARY_PATH', '') + ':' + mozjs_libdir

    # Log everything to stderr (make stderr our "log file")
    env['GJS_DEBUG_OUTPUT'] = 'stderr'

    if not options.verbose:
        # Unless verbose() is specified, only let gjs show errors and
        # things that are explicitly logged via log() from javascript
        env['GJS_DEBUG_TOPICS'] = 'JS ERROR;JS LOG'

    if use_tfp:
        # Decide if we need to set LIBGL_ALWAYS_INDIRECT=1 to get the
        # texture_from_pixmap extension; we take having the extension
        # be supported on both the client and server but not in the
        # list of effective extensions as a signal of needing to force
        # indirect rendering.
        #
        # Note that this check would give the wrong answer for Xephyr,
        # but since we force !use_tfp there anyway, it doesn't matter.
        (server_glx_extensions, client_glx_extensions, glx_extensions) = _get_glx_extensions()

        if ("GLX_EXT_texture_from_pixmap" in server_glx_extensions and
            "GLX_EXT_texture_from_pixmap" in client_glx_extensions and
            (not "GLX_EXT_texture_from_pixmap" in glx_extensions)):
            if options.verbose:
                print "Forcing indirect GL"
            # This is Mesa specific; the NVIDIA proprietary drivers
            # drivers use __GL_FORCE_INDIRECT=1 instead. But we don't
            # need to force indirect rendering for NVIDIA.
            env['LIBGL_ALWAYS_INDIRECT'] = '1'

    if options.debug:
        debug_command = options.debug_command.split()
        args = list(debug_command)
    else:
        args = []
        
    args.extend(['mutter', '--mutter-plugins=' + plugin])
    if options.replace:
        args.append('--replace')
    if options.sync:
        args.append('--sync')
    return subprocess.Popen(args, env=env)


# Main program

parser = optparse.OptionParser()
parser.add_option("-r", "--replace", action="store_true",
                  help="Replace the running metacity/gnome-panel")
parser.add_option("-g", "--debug", action="store_true",
                  help="Run under a debugger")
parser.add_option("", "--debug-command", metavar="COMMAND",
                  help="Command to use for debugging (defaults to 'gdb --args')")
parser.add_option("-v", "--verbose", action="store_true")
parser.add_option("", "--sync", action="store_true")
parser.add_option("", "--xephyr", action="store_true",
                  help="Run a debugging instance inside Xephyr")
parser.add_option("", "--geometry", metavar="GEOMETRY",
                  help="Specify Xephyr screen geometry",
                  default="1024x768");
parser.add_option("-w", "--wide", action="store_true",
                  help="Use widescreen (1280x800) with Xephyr")

options, args = parser.parse_args()

if args:
    parser.print_usage()
    sys.exit(1)

if options.debug_command:
    options.debug = True
elif options.debug:
    options.debug_command = "gdb --args"

if options.wide:
    options.geometry = "1280x800"

metacity_pid = pidof("metacity")
compiz_pid = pidof("compiz.real") or pidof("compiz")

# In Gnome 2.26 the panel grabs a dbus name and allows replacement; use that.
bus = dbus.Interface(dbus.SessionBus().get_object('org.freedesktop.DBus', '/org/freedesktop/DBus'),
                     'org.freedesktop.DBus')
names = bus.ListNames()
gnome_panel_dbus = 'org.gnome.Panel' in names
if gnome_panel_dbus:
    gnome_panel_pid = None
else:
    gnome_panel_pid = pidof("gnome-panel")

# Figure out whether or not to use GL_EXT_texture_from_pixmap. By default
# we use it iff we aren't running Xephyr, but we allow the user to
# explicitly disable it.
# FIXME: Move this to ClutterGlxPixmap like
# CLUTTER_PIXMAP_TEXTURE_RECTANGLE=disable.
if 'GNOME_SHELL_DISABLE_TFP' in os.environ and \
       os.environ['GNOME_SHELL_DISABLE_TFP'] != '':
    use_tfp = False
else:
    # tfp does not work correctly in Xephyr
    use_tfp = not options.xephyr

if options.verbose:
    print "Starting shell"

if options.debug:
    # Record initial terminal state so we can reset it to that
    # later, in case we kill gdb at a bad time
    termattrs = termios.tcgetattr(0);

# We only respawn the previous environment on abnormal exit;
# for a clean exit, we assume that gnome-shell was replaced with
# something else.
normal_exit = False

try:
    if options.xephyr:
        xephyr = start_xephyr()
        # This makes us not grab the org.gnome.Panel name
        os.environ['GNOME_SHELL_NO_REPLACE_PANEL'] = '1'
        shell = start_shell()
    else:
        xephyr = None
        if options.replace and gnome_panel_pid is not None:
            kill_gnome_panel(gnome_panel_pid)
        shell = start_shell()

    # Wait for shell to exit
    if options.verbose:
        print "Waiting for shell to exit"
    shell.wait()

except KeyboardInterrupt, e:
    try:
        os.kill(shell.pid, signal.SIGKILL)
    except:
        pass
    shell.wait()
finally:
    # Clean up Xephyr if it outlived the shell
    if xephyr:
        try:
            os.kill(xephyr.pid, signal.SIGKILL)
        except OSError:
            pass

    if shell.returncode ==  0:
        normal_exit = True
        if options.verbose:
            print "Shell exited normally"
    elif shell.returncode < 0:
        # Python has no mapping for strsignal; not worth using
        # ctypes for this.
        print "Shell killed with signal %d" % - shell.returncode
    else:
        # Normal reason here would be losing connection the X server
        if options.verbose:
            print "Shell exited with return code %d" % shell.returncode

    if options.debug:
        termios.tcsetattr(0, termios.TCSANOW, termattrs);

    if not options.xephyr and options.replace and not normal_exit:
        # Restart gnome-panel and window manager

        # We don't want to start the new gnome-panel in the current
        # directory; $HOME is better for stuff launched from it
        os.chdir(os.path.expanduser("~"))

        if metacity_pid:
            if options.verbose:
                print "Restarting Metacity"
            subprocess.Popen(["/usr/bin/metacity"])
        elif compiz_pid:
            if options.verbose:
                print "Restarting Compiz"
            subprocess.Popen(["/usr/bin/compiz"])
        if gnome_panel_dbus or gnome_panel_pid:
            if options.verbose:
                print "Restarting gnome-panel"
            subprocess.Popen(["/usr/bin/gnome-panel"])