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

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")
        taskpanel_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')
        taskpanel_dir = '@libexecdir@'

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

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

    # 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(['metacity', '--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")
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()
        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_pid:
            if options.verbose:
                print "Restarting gnome-panel"
            subprocess.Popen(["/usr/bin/gnome-panel"])