summaryrefslogtreecommitdiffstats
path: root/addon-sdk/source/python-lib/mozrunner/__init__.py
diff options
context:
space:
mode:
Diffstat (limited to 'addon-sdk/source/python-lib/mozrunner/__init__.py')
-rw-r--r--addon-sdk/source/python-lib/mozrunner/__init__.py694
1 files changed, 0 insertions, 694 deletions
diff --git a/addon-sdk/source/python-lib/mozrunner/__init__.py b/addon-sdk/source/python-lib/mozrunner/__init__.py
deleted file mode 100644
index 87c2c320f..000000000
--- a/addon-sdk/source/python-lib/mozrunner/__init__.py
+++ /dev/null
@@ -1,694 +0,0 @@
-# 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/.
-
-import os
-import sys
-import copy
-import tempfile
-import signal
-import commands
-import zipfile
-import optparse
-import killableprocess
-import subprocess
-import platform
-import shutil
-from StringIO import StringIO
-from xml.dom import minidom
-
-from distutils import dir_util
-from time import sleep
-
-# conditional (version-dependent) imports
-try:
- import simplejson
-except ImportError:
- import json as simplejson
-
-import logging
-logger = logging.getLogger(__name__)
-
-# Use dir_util for copy/rm operations because shutil is all kinds of broken
-copytree = dir_util.copy_tree
-rmtree = dir_util.remove_tree
-
-def findInPath(fileName, path=os.environ['PATH']):
- dirs = path.split(os.pathsep)
- for dir in dirs:
- if os.path.isfile(os.path.join(dir, fileName)):
- return os.path.join(dir, fileName)
- if os.name == 'nt' or sys.platform == 'cygwin':
- if os.path.isfile(os.path.join(dir, fileName + ".exe")):
- return os.path.join(dir, fileName + ".exe")
- return None
-
-stdout = sys.stdout
-stderr = sys.stderr
-stdin = sys.stdin
-
-def run_command(cmd, env=None, **kwargs):
- """Run the given command in killable process."""
- killable_kwargs = {'stdout':stdout ,'stderr':stderr, 'stdin':stdin}
- killable_kwargs.update(kwargs)
-
- if sys.platform != "win32":
- return killableprocess.Popen(cmd, preexec_fn=lambda : os.setpgid(0, 0),
- env=env, **killable_kwargs)
- else:
- return killableprocess.Popen(cmd, env=env, **killable_kwargs)
-
-def getoutput(l):
- tmp = tempfile.mktemp()
- x = open(tmp, 'w')
- subprocess.call(l, stdout=x, stderr=x)
- x.close(); x = open(tmp, 'r')
- r = x.read() ; x.close()
- os.remove(tmp)
- return r
-
-def get_pids(name, minimun_pid=0):
- """Get all the pids matching name, exclude any pids below minimum_pid."""
- if os.name == 'nt' or sys.platform == 'cygwin':
- import wpk
-
- pids = wpk.get_pids(name)
-
- else:
- data = getoutput(['ps', 'ax']).splitlines()
- pids = [int(line.split()[0]) for line in data if line.find(name) is not -1]
-
- matching_pids = [m for m in pids if m > minimun_pid]
- return matching_pids
-
-def makedirs(name):
-
- head, tail = os.path.split(name)
- if not tail:
- head, tail = os.path.split(head)
- if head and tail and not os.path.exists(head):
- try:
- makedirs(head)
- except OSError, e:
- pass
- if tail == os.curdir: # xxx/newdir/. exists if xxx/newdir exists
- return
- try:
- os.mkdir(name)
- except:
- pass
-
-# addon_details() copied from mozprofile
-def addon_details(install_rdf_fh):
- """
- returns a dictionary of details about the addon
- - addon_path : path to the addon directory
- Returns:
- {'id': u'rainbow@colors.org', # id of the addon
- 'version': u'1.4', # version of the addon
- 'name': u'Rainbow', # name of the addon
- 'unpack': # whether to unpack the addon
- """
-
- details = {
- 'id': None,
- 'unpack': False,
- 'name': None,
- 'version': None
- }
-
- def get_namespace_id(doc, url):
- attributes = doc.documentElement.attributes
- namespace = ""
- for i in range(attributes.length):
- if attributes.item(i).value == url:
- if ":" in attributes.item(i).name:
- # If the namespace is not the default one remove 'xlmns:'
- namespace = attributes.item(i).name.split(':')[1] + ":"
- break
- return namespace
-
- def get_text(element):
- """Retrieve the text value of a given node"""
- rc = []
- for node in element.childNodes:
- if node.nodeType == node.TEXT_NODE:
- rc.append(node.data)
- return ''.join(rc).strip()
-
- doc = minidom.parse(install_rdf_fh)
-
- # Get the namespaces abbreviations
- em = get_namespace_id(doc, "http://www.mozilla.org/2004/em-rdf#")
- rdf = get_namespace_id(doc, "http://www.w3.org/1999/02/22-rdf-syntax-ns#")
-
- description = doc.getElementsByTagName(rdf + "Description").item(0)
- for node in description.childNodes:
- # Remove the namespace prefix from the tag for comparison
- entry = node.nodeName.replace(em, "")
- if entry in details.keys():
- details.update({ entry: get_text(node) })
-
- # turn unpack into a true/false value
- if isinstance(details['unpack'], basestring):
- details['unpack'] = details['unpack'].lower() == 'true'
-
- return details
-
-class Profile(object):
- """Handles all operations regarding profile. Created new profiles, installs extensions,
- sets preferences and handles cleanup."""
-
- def __init__(self, binary=None, profile=None, addons=None,
- preferences=None):
-
- self.binary = binary
-
- self.create_new = not(bool(profile))
- if profile:
- self.profile = profile
- else:
- self.profile = self.create_new_profile(self.binary)
-
- self.addons_installed = []
- self.addons = addons or []
-
- ### set preferences from class preferences
- preferences = preferences or {}
- if hasattr(self.__class__, 'preferences'):
- self.preferences = self.__class__.preferences.copy()
- else:
- self.preferences = {}
- self.preferences.update(preferences)
-
- for addon in self.addons:
- self.install_addon(addon)
-
- self.set_preferences(self.preferences)
-
- def create_new_profile(self, binary):
- """Create a new clean profile in tmp which is a simple empty folder"""
- profile = tempfile.mkdtemp(suffix='.mozrunner')
- return profile
-
- def unpack_addon(self, xpi_zipfile, addon_path):
- for name in xpi_zipfile.namelist():
- if name.endswith('/'):
- makedirs(os.path.join(addon_path, name))
- else:
- if not os.path.isdir(os.path.dirname(os.path.join(addon_path, name))):
- makedirs(os.path.dirname(os.path.join(addon_path, name)))
- data = xpi_zipfile.read(name)
- f = open(os.path.join(addon_path, name), 'wb')
- f.write(data) ; f.close()
- zi = xpi_zipfile.getinfo(name)
- os.chmod(os.path.join(addon_path,name), (zi.external_attr>>16))
-
- def install_addon(self, path):
- """Installs the given addon or directory of addons in the profile."""
-
- extensions_path = os.path.join(self.profile, 'extensions')
- if not os.path.exists(extensions_path):
- os.makedirs(extensions_path)
-
- addons = [path]
- if not path.endswith('.xpi') and not os.path.exists(os.path.join(path, 'install.rdf')):
- addons = [os.path.join(path, x) for x in os.listdir(path)]
-
- for addon in addons:
- if addon.endswith('.xpi'):
- xpi_zipfile = zipfile.ZipFile(addon, "r")
- details = addon_details(StringIO(xpi_zipfile.read('install.rdf')))
- addon_path = os.path.join(extensions_path, details["id"])
- if details.get("unpack", True):
- self.unpack_addon(xpi_zipfile, addon_path)
- self.addons_installed.append(addon_path)
- else:
- shutil.copy(addon, addon_path + '.xpi')
- else:
- # it's already unpacked, but we need to extract the id so we
- # can copy it
- details = addon_details(open(os.path.join(addon, "install.rdf"), "rb"))
- addon_path = os.path.join(extensions_path, details["id"])
- shutil.copytree(addon, addon_path, symlinks=True)
-
- def set_preferences(self, preferences):
- """Adds preferences dict to profile preferences"""
- prefs_file = os.path.join(self.profile, 'user.js')
- # Ensure that the file exists first otherwise create an empty file
- if os.path.isfile(prefs_file):
- f = open(prefs_file, 'a+')
- else:
- f = open(prefs_file, 'w')
-
- f.write('\n#MozRunner Prefs Start\n')
-
- pref_lines = ['user_pref(%s, %s);' %
- (simplejson.dumps(k), simplejson.dumps(v) ) for k, v in
- preferences.items()]
- for line in pref_lines:
- f.write(line+'\n')
- f.write('#MozRunner Prefs End\n')
- f.flush() ; f.close()
-
- def pop_preferences(self):
- """
- pop the last set of preferences added
- returns True if popped
- """
-
- # our magic markers
- delimeters = ('#MozRunner Prefs Start', '#MozRunner Prefs End')
-
- lines = file(os.path.join(self.profile, 'user.js')).read().splitlines()
- def last_index(_list, value):
- """
- returns the last index of an item;
- this should actually be part of python code but it isn't
- """
- for index in reversed(range(len(_list))):
- if _list[index] == value:
- return index
- s = last_index(lines, delimeters[0])
- e = last_index(lines, delimeters[1])
-
- # ensure both markers are found
- if s is None:
- assert e is None, '%s found without %s' % (delimeters[1], delimeters[0])
- return False # no preferences found
- elif e is None:
- assert e is None, '%s found without %s' % (delimeters[0], delimeters[1])
-
- # ensure the markers are in the proper order
- assert e > s, '%s found at %s, while %s found at %s' (delimeter[1], e, delimeter[0], s)
-
- # write the prefs
- cleaned_prefs = '\n'.join(lines[:s] + lines[e+1:])
- f = file(os.path.join(self.profile, 'user.js'), 'w')
- f.write(cleaned_prefs)
- f.close()
- return True
-
- def clean_preferences(self):
- """Removed preferences added by mozrunner."""
- while True:
- if not self.pop_preferences():
- break
-
- def clean_addons(self):
- """Cleans up addons in the profile."""
- for addon in self.addons_installed:
- if os.path.isdir(addon):
- rmtree(addon)
-
- def cleanup(self):
- """Cleanup operations on the profile."""
- def oncleanup_error(function, path, excinfo):
- #TODO: How should we handle this?
- print "Error Cleaning up: " + str(excinfo[1])
- if self.create_new:
- shutil.rmtree(self.profile, False, oncleanup_error)
- else:
- self.clean_preferences()
- self.clean_addons()
-
-class FirefoxProfile(Profile):
- """Specialized Profile subclass for Firefox"""
- preferences = {# Don't automatically update the application
- 'app.update.enabled' : False,
- # Don't restore the last open set of tabs if the browser has crashed
- 'browser.sessionstore.resume_from_crash': False,
- # Don't check for the default web browser
- 'browser.shell.checkDefaultBrowser' : False,
- # Don't warn on exit when multiple tabs are open
- 'browser.tabs.warnOnClose' : False,
- # Don't warn when exiting the browser
- 'browser.warnOnQuit': False,
- # Only install add-ons from the profile and the app folder
- 'extensions.enabledScopes' : 5,
- # Don't automatically update add-ons
- 'extensions.update.enabled' : False,
- # Don't open a dialog to show available add-on updates
- 'extensions.update.notifyUser' : False,
- }
-
- # The possible names of application bundles on Mac OS X, in order of
- # preference from most to least preferred.
- # Note: Nightly is obsolete, as it has been renamed to FirefoxNightly,
- # but it will still be present if users update an older nightly build
- # via the app update service.
- bundle_names = ['Firefox', 'FirefoxNightly', 'Nightly']
-
- # The possible names of binaries, in order of preference from most to least
- # preferred.
- @property
- def names(self):
- if sys.platform == 'darwin':
- return ['firefox', 'nightly', 'shiretoko']
- if (sys.platform == 'linux2') or (sys.platform in ('sunos5', 'solaris')):
- return ['firefox', 'mozilla-firefox', 'iceweasel']
- if os.name == 'nt' or sys.platform == 'cygwin':
- return ['firefox']
-
-class ThunderbirdProfile(Profile):
- preferences = {'extensions.update.enabled' : False,
- 'extensions.update.notifyUser' : False,
- 'browser.shell.checkDefaultBrowser' : False,
- 'browser.tabs.warnOnClose' : False,
- 'browser.warnOnQuit': False,
- 'browser.sessionstore.resume_from_crash': False,
- }
-
- # The possible names of application bundles on Mac OS X, in order of
- # preference from most to least preferred.
- bundle_names = ["Thunderbird", "Shredder"]
-
- # The possible names of binaries, in order of preference from most to least
- # preferred.
- names = ["thunderbird", "shredder"]
-
-
-class Runner(object):
- """Handles all running operations. Finds bins, runs and kills the process."""
-
- def __init__(self, binary=None, profile=None, cmdargs=[], env=None,
- kp_kwargs={}):
- if binary is None:
- self.binary = self.find_binary()
- elif sys.platform == 'darwin' and binary.find('Contents/MacOS/') == -1:
- self.binary = os.path.join(binary, 'Contents/MacOS/%s-bin' % self.names[0])
- else:
- self.binary = binary
-
- if not os.path.exists(self.binary):
- raise Exception("Binary path does not exist "+self.binary)
-
- if sys.platform == 'linux2' and self.binary.endswith('-bin'):
- dirname = os.path.dirname(self.binary)
- if os.environ.get('LD_LIBRARY_PATH', None):
- os.environ['LD_LIBRARY_PATH'] = '%s:%s' % (os.environ['LD_LIBRARY_PATH'], dirname)
- else:
- os.environ['LD_LIBRARY_PATH'] = dirname
-
- # Disable the crash reporter by default
- os.environ['MOZ_CRASHREPORTER_NO_REPORT'] = '1'
-
- self.profile = profile
-
- self.cmdargs = cmdargs
- if env is None:
- self.env = copy.copy(os.environ)
- self.env.update({'MOZ_NO_REMOTE':"1",})
- else:
- self.env = env
- self.kp_kwargs = kp_kwargs or {}
-
- def find_binary(self):
- """Finds the binary for self.names if one was not provided."""
- binary = None
- if sys.platform in ('linux2', 'sunos5', 'solaris') \
- or sys.platform.startswith('freebsd'):
- for name in reversed(self.names):
- binary = findInPath(name)
- elif os.name == 'nt' or sys.platform == 'cygwin':
-
- # find the default executable from the windows registry
- try:
- import _winreg
- except ImportError:
- pass
- else:
- sam_flags = [0]
- # KEY_WOW64_32KEY etc only appeared in 2.6+, but that's OK as
- # only 2.6+ has functioning 64bit builds.
- if hasattr(_winreg, "KEY_WOW64_32KEY"):
- if "64 bit" in sys.version:
- # a 64bit Python should also look in the 32bit registry
- sam_flags.append(_winreg.KEY_WOW64_32KEY)
- else:
- # possibly a 32bit Python on 64bit Windows, so look in
- # the 64bit registry incase there is a 64bit app.
- sam_flags.append(_winreg.KEY_WOW64_64KEY)
- for sam_flag in sam_flags:
- try:
- # assumes self.app_name is defined, as it should be for
- # implementors
- keyname = r"Software\Mozilla\Mozilla %s" % self.app_name
- sam = _winreg.KEY_READ | sam_flag
- app_key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, keyname, 0, sam)
- version, _type = _winreg.QueryValueEx(app_key, "CurrentVersion")
- version_key = _winreg.OpenKey(app_key, version + r"\Main")
- path, _ = _winreg.QueryValueEx(version_key, "PathToExe")
- return path
- except _winreg.error:
- pass
-
- # search for the binary in the path
- for name in reversed(self.names):
- binary = findInPath(name)
- if sys.platform == 'cygwin':
- program_files = os.environ['PROGRAMFILES']
- else:
- program_files = os.environ['ProgramFiles']
-
- if binary is None:
- for bin in [(program_files, 'Mozilla Firefox', 'firefox.exe'),
- (os.environ.get("ProgramFiles(x86)"),'Mozilla Firefox', 'firefox.exe'),
- (program_files, 'Nightly', 'firefox.exe'),
- (os.environ.get("ProgramFiles(x86)"),'Nightly', 'firefox.exe'),
- (program_files, 'Aurora', 'firefox.exe'),
- (os.environ.get("ProgramFiles(x86)"),'Aurora', 'firefox.exe')
- ]:
- path = os.path.join(*bin)
- if os.path.isfile(path):
- binary = path
- break
- elif sys.platform == 'darwin':
- for bundle_name in self.bundle_names:
- # Look for the application bundle in the user's home directory
- # or the system-wide /Applications directory. If we don't find
- # it in one of those locations, we move on to the next possible
- # bundle name.
- appdir = os.path.join("~/Applications/%s.app" % bundle_name)
- if not os.path.isdir(appdir):
- appdir = "/Applications/%s.app" % bundle_name
- if not os.path.isdir(appdir):
- continue
-
- # Look for a binary with any of the possible binary names
- # inside the application bundle.
- for binname in self.names:
- binpath = os.path.join(appdir,
- "Contents/MacOS/%s-bin" % binname)
- if (os.path.isfile(binpath)):
- binary = binpath
- break
-
- if binary:
- break
-
- if binary is None:
- raise Exception('Mozrunner could not locate your binary, you will need to set it.')
- return binary
-
- @property
- def command(self):
- """Returns the command list to run."""
- cmd = [self.binary, '-profile', self.profile.profile]
- # On i386 OS X machines, i386+x86_64 universal binaries need to be told
- # to run as i386 binaries. If we're not running a i386+x86_64 universal
- # binary, then this command modification is harmless.
- if sys.platform == 'darwin':
- if hasattr(platform, 'architecture') and platform.architecture()[0] == '32bit':
- cmd = ['arch', '-i386'] + cmd
- return cmd
-
- def get_repositoryInfo(self):
- """Read repository information from application.ini and platform.ini."""
- import ConfigParser
-
- config = ConfigParser.RawConfigParser()
- dirname = os.path.dirname(self.binary)
- repository = { }
-
- for entry in [['application', 'App'], ['platform', 'Build']]:
- (file, section) = entry
- config.read(os.path.join(dirname, '%s.ini' % file))
-
- for entry in [['SourceRepository', 'repository'], ['SourceStamp', 'changeset']]:
- (key, id) = entry
-
- try:
- repository['%s_%s' % (file, id)] = config.get(section, key);
- except:
- repository['%s_%s' % (file, id)] = None
-
- return repository
-
- def start(self):
- """Run self.command in the proper environment."""
- if self.profile is None:
- self.profile = self.profile_class()
- self.process_handler = run_command(self.command+self.cmdargs, self.env, **self.kp_kwargs)
-
- def wait(self, timeout=None):
- """Wait for the browser to exit."""
- self.process_handler.wait(timeout=timeout)
-
- if sys.platform != 'win32':
- for name in self.names:
- for pid in get_pids(name, self.process_handler.pid):
- self.process_handler.pid = pid
- self.process_handler.wait(timeout=timeout)
-
- def kill(self, kill_signal=signal.SIGTERM):
- """Kill the browser"""
- if sys.platform != 'win32':
- self.process_handler.kill()
- for name in self.names:
- for pid in get_pids(name, self.process_handler.pid):
- self.process_handler.pid = pid
- self.process_handler.kill()
- else:
- try:
- self.process_handler.kill(group=True)
- # On windows, it sometimes behooves one to wait for dust to settle
- # after killing processes. Let's try that.
- # TODO: Bug 640047 is invesitgating the correct way to handle this case
- self.process_handler.wait(timeout=10)
- except Exception, e:
- logger.error('Cannot kill process, '+type(e).__name__+' '+e.message)
-
- def stop(self):
- self.kill()
-
-class FirefoxRunner(Runner):
- """Specialized Runner subclass for running Firefox."""
-
- app_name = 'Firefox'
- profile_class = FirefoxProfile
-
- # The possible names of application bundles on Mac OS X, in order of
- # preference from most to least preferred.
- # Note: Nightly is obsolete, as it has been renamed to FirefoxNightly,
- # but it will still be present if users update an older nightly build
- # only via the app update service.
- bundle_names = ['Firefox', 'FirefoxNightly', 'Nightly']
-
- @property
- def names(self):
- if sys.platform == 'darwin':
- return ['firefox', 'nightly', 'shiretoko']
- if sys.platform in ('linux2', 'sunos5', 'solaris') \
- or sys.platform.startswith('freebsd'):
- return ['firefox', 'mozilla-firefox', 'iceweasel']
- if os.name == 'nt' or sys.platform == 'cygwin':
- return ['firefox']
-
-class ThunderbirdRunner(Runner):
- """Specialized Runner subclass for running Thunderbird"""
-
- app_name = 'Thunderbird'
- profile_class = ThunderbirdProfile
-
- # The possible names of application bundles on Mac OS X, in order of
- # preference from most to least preferred.
- bundle_names = ["Thunderbird", "Shredder"]
-
- # The possible names of binaries, in order of preference from most to least
- # preferred.
- names = ["thunderbird", "shredder"]
-
-class CLI(object):
- """Command line interface."""
-
- runner_class = FirefoxRunner
- profile_class = FirefoxProfile
- module = "mozrunner"
-
- parser_options = {("-b", "--binary",): dict(dest="binary", help="Binary path.",
- metavar=None, default=None),
- ('-p', "--profile",): dict(dest="profile", help="Profile path.",
- metavar=None, default=None),
- ('-a', "--addons",): dict(dest="addons",
- help="Addons paths to install.",
- metavar=None, default=None),
- ("--info",): dict(dest="info", default=False,
- action="store_true",
- help="Print module information")
- }
-
- def __init__(self):
- """ Setup command line parser and parse arguments """
- self.metadata = self.get_metadata_from_egg()
- self.parser = optparse.OptionParser(version="%prog " + self.metadata["Version"])
- for names, opts in self.parser_options.items():
- self.parser.add_option(*names, **opts)
- (self.options, self.args) = self.parser.parse_args()
-
- if self.options.info:
- self.print_metadata()
- sys.exit(0)
-
- # XXX should use action='append' instead of rolling our own
- try:
- self.addons = self.options.addons.split(',')
- except:
- self.addons = []
-
- 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]
-
- def create_runner(self):
- """ Get the runner object """
- runner = self.get_runner(binary=self.options.binary)
- profile = self.get_profile(binary=runner.binary,
- profile=self.options.profile,
- addons=self.addons)
- runner.profile = profile
- return runner
-
- def get_runner(self, binary=None, profile=None):
- """Returns the runner instance for the given command line binary argument
- the profile instance returned from self.get_profile()."""
- return self.runner_class(binary, profile)
-
- def get_profile(self, binary=None, profile=None, addons=None, preferences=None):
- """Returns the profile instance for the given command line arguments."""
- addons = addons or []
- preferences = preferences or {}
- return self.profile_class(binary, profile, addons, preferences)
-
- def run(self):
- runner = self.create_runner()
- self.start(runner)
- runner.profile.cleanup()
-
- def start(self, runner):
- """Starts the runner and waits for Firefox to exitor Keyboard Interrupt.
- Shoule be overwritten to provide custom running of the runner instance."""
- runner.start()
- print 'Started:', ' '.join(runner.command)
- try:
- runner.wait()
- except KeyboardInterrupt:
- runner.stop()
-
-
-def cli():
- CLI().run()