Adding mozilla libraries required by Firefox interop test.

third_party/mozrunner/mozrunner/runner.py

+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+
+__all__ = ['Runner', 'ThunderbirdRunner', 'FirefoxRunner', 'runners', 'CLI', 'cli', 'package_metadata']
+
+import mozinfo
+import optparse
+import os
+import platform
+import subprocess
+import sys
+import ConfigParser
+
+from utils import get_metadata_from_egg
+from utils import findInPath
+from mozprofile import *
+from mozprocess.processhandler import ProcessHandler
+
+if mozinfo.isMac:
+    from plistlib import readPlist
+
+package_metadata = get_metadata_from_egg('mozrunner')
+
+# Map of debugging programs to information about them
+# from http://mxr.mozilla.org/mozilla-central/source/build/automationutils.py#59
+debuggers = {'gdb': {'interactive': True,
+                     'args': ['-q', '--args'],},
+             'valgrind': {'interactive': False,
+                          'args': ['--leak-check=full']}
+             }
+
+def debugger_arguments(debugger, arguments=None, interactive=None):
+    """
+    finds debugger arguments from debugger given and defaults
+    * debugger : debugger name or path to debugger
+    * arguments : arguments to the debugger, or None to use defaults
+    * interactive : whether the debugger should be run in interactive mode, or None to use default
+    """
+
+    # find debugger executable if not a file
+    executable = debugger
+    if not os.path.exists(executable):
+        executable = findInPath(debugger)
+    if executable is None:
+        raise Exception("Path to '%s' not found" % debugger)
+
+    # if debugger not in dictionary of knowns return defaults
+    dirname, debugger = os.path.split(debugger)
+    if debugger not in debuggers:
+        return ([executable] + (arguments or []), bool(interactive))
+
+    # otherwise use the dictionary values for arguments unless specified
+    if arguments is None:
+        arguments = debuggers[debugger].get('args', [])
+    if interactive is None:
+        interactive = debuggers[debugger].get('interactive', False)
+    return ([executable] + arguments, interactive)
+
+class Runner(object):
+    """Handles all running operations. Finds bins, runs and kills the process."""
+
+    profile_class = Profile # profile class to use by default
+
+    @classmethod
+    def create(cls, binary=None, cmdargs=None, env=None, kp_kwargs=None, profile_args=None,
+               clean_profile=True, process_class=ProcessHandler):
+        profile = cls.profile_class(**(profile_args or {}))
+        return cls(profile, binary=binary, cmdargs=cmdargs, env=env, kp_kwargs=kp_kwargs,
+                                           clean_profile=clean_profile, process_class=process_class)
+
+    def __init__(self, profile, binary, cmdargs=None, env=None,
+                 kp_kwargs=None, clean_profile=True, process_class=ProcessHandler):
+        self.process_handler = None
+        self.process_class = process_class
+        self.profile = profile
+        self.clean_profile = clean_profile
+
+        # find the binary
+        self.binary = binary
+        if not self.binary:
+            raise Exception("Binary not specified")
+        if not os.path.exists(self.binary):
+            raise OSError("Binary path does not exist: %s" % self.binary)
+
+        # allow Mac binaries to be specified as an app bundle
+        plist = '%s/Contents/Info.plist' % self.binary
+        if mozinfo.isMac and os.path.exists(plist):
+            info = readPlist(plist)
+            self.binary = os.path.join(self.binary, "Contents/MacOS/",
+                                       info['CFBundleExecutable'])
+
+        self.cmdargs = cmdargs or []
+        _cmdargs = [i for i in self.cmdargs
+                    if i != '-foreground']
+        if len(_cmdargs) != len(self.cmdargs):
+            # foreground should be last; see
+            # - https://bugzilla.mozilla.org/show_bug.cgi?id=625614
+            # - https://bugzilla.mozilla.org/show_bug.cgi?id=626826
+            self.cmdargs = _cmdargs
+            self.cmdargs.append('-foreground')
+
+        # process environment
+        if env is None:
+            self.env = os.environ.copy()
+        else:
+            self.env = env.copy()
+        # allows you to run an instance of Firefox separately from any other instances
+        self.env['MOZ_NO_REMOTE'] = '1'
+        # keeps Firefox attached to the terminal window after it starts
+        self.env['NO_EM_RESTART'] = '1'
+
+        # set the library path if needed on linux
+        if sys.platform == 'linux2' and self.binary.endswith('-bin'):
+            dirname = os.path.dirname(self.binary)
+            if os.environ.get('LD_LIBRARY_PATH', None):
+                self.env['LD_LIBRARY_PATH'] = '%s:%s' % (os.environ['LD_LIBRARY_PATH'], dirname)
+            else:
+                self.env['LD_LIBRARY_PATH'] = dirname
+
+        # arguments for ProfessHandler.Process
+        self.kp_kwargs = kp_kwargs or {}
+
+    @property
+    def command(self):
+        """Returns the command list to run."""
+        return [self.binary, '-profile', self.profile.profile]
+
+    def get_repositoryInfo(self):
+        """Read repository information from application.ini and platform.ini."""
+
+        config = ConfigParser.RawConfigParser()
+        dirname = os.path.dirname(self.binary)
+        repository = { }
+
+        for file, section in [('application', 'App'), ('platform', 'Build')]:
+            config.read(os.path.join(dirname, '%s.ini' % file))
+
+            for key, id in [('SourceRepository', 'repository'),
+                            ('SourceStamp', 'changeset')]:
+                try:
+                    repository['%s_%s' % (file, id)] = config.get(section, key);
+                except:
+                    repository['%s_%s' % (file, id)] = None
+
+        return repository
+
+    def is_running(self):
+        return self.process_handler is not None
+
+    def start(self, debug_args=None, interactive=False, timeout=None, outputTimeout=None):
+        """
+        Run self.command in the proper environment.
+        - debug_args: arguments for the debugger
+        - interactive: uses subprocess.Popen directly
+        - read_output: sends program output to stdout [default=False]
+        - timeout: see process_handler.waitForFinish
+        - outputTimeout: see process_handler.waitForFinish
+        """
+
+        # ensure you are stopped
+        self.stop()
+
+        # ensure the profile exists
+        if not self.profile.exists():
+            self.profile.reset()
+            assert self.profile.exists(), "%s : failure to reset profile" % self.__class__.__name__
+
+        cmd = self._wrap_command(self.command+self.cmdargs)
+
+        # attach a debugger, if specified
+        if debug_args:
+            cmd = list(debug_args) + cmd
+
+        if interactive:
+            self.process_handler = subprocess.Popen(cmd, env=self.env)
+            # TODO: other arguments
+        else:
+            # this run uses the managed processhandler
+            self.process_handler = self.process_class(cmd, env=self.env, **self.kp_kwargs)
+            self.process_handler.run(timeout, outputTimeout)
+
+    def wait(self, timeout=None):
+        """
+        Wait for the app to exit.
+
+        If timeout is not None, will return after timeout seconds.
+        Use is_running() to determine whether or not a timeout occured.
+        Timeout is ignored if interactive was set to True.
+        """
+        if self.process_handler is None:
+            return
+
+        if isinstance(self.process_handler, subprocess.Popen):
+            self.process_handler.wait()
+        else:
+            self.process_handler.wait(timeout)
+            if self.process_handler.proc.poll() is None:
+                # waitForFinish timed out
+                return
+
+        self.process_handler = None
+
+    def stop(self):
+        """Kill the app"""
+        if self.process_handler is None:
+            return
+        self.process_handler.kill()
+        self.process_handler = None
+
+    def reset(self):
+        """
+        reset the runner between runs
+        currently, only resets the profile, but probably should do more
+        """
+        self.profile.reset()
+
+    def cleanup(self):
+        self.stop()
+        if self.clean_profile:
+            self.profile.cleanup()
+
+    def _wrap_command(self, cmd):
+        """
+        If running on OS X 10.5 or older, wrap |cmd| so that it will
+        be executed as an i386 binary, in case it's a 32-bit/64-bit universal
+        binary.
+        """
+        if mozinfo.isMac and hasattr(platform, 'mac_ver') and \
+                               platform.mac_ver()[0][:4] < '10.6':
+            return ["arch", "-arch", "i386"] + cmd
+        return cmd
+
+    __del__ = cleanup
+
+
+class FirefoxRunner(Runner):
+    """Specialized Runner subclass for running Firefox."""
+
+    profile_class = FirefoxProfile
+
+    def __init__(self, profile, binary=None, **kwargs):
+
+        # take the binary from BROWSER_PATH environment variable
+        if (not binary) and 'BROWSER_PATH' in os.environ:
+            binary = os.environ['BROWSER_PATH']
+
+        Runner.__init__(self, profile, binary, **kwargs)
+
+class ThunderbirdRunner(Runner):
+    """Specialized Runner subclass for running Thunderbird"""
+    profile_class = ThunderbirdProfile
+
+runners = {'firefox': FirefoxRunner,
+           'thunderbird': ThunderbirdRunner}
+
+class CLI(MozProfileCLI):
+    """Command line interface."""
+
+    module = "mozrunner"
+
+    def __init__(self, args=sys.argv[1:]):
+        """
+        Setup command line parser and parse arguments
+        - args : command line arguments
+        """
+
+        self.metadata = getattr(sys.modules[self.module],
+                                'package_metadata',
+                                {})
+        version = self.metadata.get('Version')
+        parser_args = {'description': self.metadata.get('Summary')}
+        if version:
+            parser_args['version'] = "%prog " + version
+        self.parser = optparse.OptionParser(**parser_args)
+        self.add_options(self.parser)
+        (self.options, self.args) = self.parser.parse_args(args)
+
+        if getattr(self.options, 'info', None):
+            self.print_metadata()
+            sys.exit(0)
+
+        # choose appropriate runner and profile classes
+        try:
+            self.runner_class = runners[self.options.app]
+        except KeyError:
+            self.parser.error('Application "%s" unknown (should be one of "firefox" or "thunderbird")' % self.options.app)
+
+    def add_options(self, parser):
+        """add options to the parser"""
+
+        # add profile options
+        MozProfileCLI.add_options(self, parser)
+
+        # add runner options
+        parser.add_option('-b', "--binary",
+                          dest="binary", help="Binary path.",
+                          metavar=None, default=None)
+        parser.add_option('--app', dest='app', default='firefox',
+                          help="Application to use [DEFAULT: %default]")
+        parser.add_option('--app-arg', dest='appArgs',
+                          default=[], action='append',
+                          help="provides an argument to the test application")
+        parser.add_option('--debugger', dest='debugger',
+                          help="run under a debugger, e.g. gdb or valgrind")
+        parser.add_option('--debugger-args', dest='debugger_args',
+                          action='append', default=None,
+                          help="arguments to the debugger")
+        parser.add_option('--interactive', dest='interactive',
+                          action='store_true',
+                          help="run the program interactively")
+        if self.metadata:
+            parser.add_option("--info", dest="info", default=False,
+                              action="store_true",
+                              help="Print module information")
+
+    ### methods for introspecting data
+
+    def get_metadata_from_egg(self):
+        import pkg_resources
+        ret = {}
+        dist = pkg_resources.get_distribution(self.module)
+        if dist.has_metadata("PKG-INFO"):
+            for line in dist.get_metadata_lines("PKG-INFO"):
+                key, value = line.split(':', 1)
+                ret[key] = value
+        if dist.has_metadata("requires.txt"):
+            ret["Dependencies"] = "\n" + dist.get_metadata("requires.txt")
+        return ret
+
+    def print_metadata(self, data=("Name", "Version", "Summary", "Home-page",
+                                   "Author", "Author-email", "License", "Platform", "Dependencies")):
+        for key in data:
+            if key in self.metadata:
+                print key + ": " + self.metadata[key]
+
+    ### methods for running
+
+    def command_args(self):
+        """additional arguments for the mozilla application"""
+        return self.options.appArgs
+
+    def runner_args(self):
+        """arguments to instantiate the runner class"""
+        return dict(cmdargs=self.command_args(),
+                    binary=self.options.binary,
+                    profile_args=self.profile_args())
+
+    def create_runner(self):
+        return self.runner_class.create(**self.runner_args())
+
+    def run(self):
+        runner = self.create_runner()
+        self.start(runner)
+        runner.cleanup()
+
+    def debugger_arguments(self):
+        """
+        returns a 2-tuple of debugger arguments:
+        (debugger_arguments, interactive)
+        """
+        debug_args = self.options.debugger_args
+        interactive = self.options.interactive
+        if self.options.debugger:
+            debug_args, interactive = debugger_arguments(self.options.debugger)
+        return debug_args, interactive
+
+    def start(self, runner):
+        """Starts the runner and waits for Firefox to exit or Keyboard Interrupt.
+        Shoule be overwritten to provide custom running of the runner instance."""
+
+        # attach a debugger if specified
+        debug_args, interactive = self.debugger_arguments()
+        runner.start(debug_args=debug_args, interactive=interactive)
+        print 'Starting:', ' '.join(runner.command)
+        try:
+            runner.wait()
+        except KeyboardInterrupt:
+            runner.stop()
+
+
+def cli(args=sys.argv[1:]):
+    CLI(args).run()
+
+if __name__ == '__main__':
+    cli()