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, '--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("", "--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")

# Run in Xephyr if gnome-panel is already running and the user didn't
# specify --replace. Otherwise, run fullscreen
if options.replace:
    run_in_xephyr = False
else:
    run_in_xephyr = (metacity_pid != None or compiz_pid != None or
        gnome_panel_pid != None)

# 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 run_in_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);

try:
    if run_in_xephyr:
        shell = start_xephyr()
        # This makes us not grab the org.gnome.Panel name
        os.environ['GNOME_SHELL_NO_REPLACE_PANEL'] = '1'
        start_shell()
    else:
        if 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()
    if options.verbose:
        print "Shell is dead"

except KeyboardInterrupt, e:
    try:
        os.kill(shell.pid, signal.SIGKILL)
    except:
        pass
    shell.wait()
    if options.verbose:
        print "Shell killed"

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

    if not run_in_xephyr:
        # Restart gnome-panel and window manager
        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"])