blob: 2f19a2ccac876679486d821c729fbf2b0443e437 [file] [log] [blame]
# Version: MPL 1.1/GPL 2.0/LGPL 2.1
# The contents of this file are subject to the Mozilla Public License Version
# 1.1 (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
# Software distributed under the License is distributed on an "AS IS" basis,
# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
# for the specific language governing rights and limitations under the
# License.
# The Original Code is Mozilla Corporation Code.
# The Initial Developer of the Original Code is
# Mikeal Rogers.
# Portions created by the Initial Developer are Copyright (C) 2008-2009
# the Initial Developer. All Rights Reserved.
# Contributor(s):
# Mikeal Rogers <>
# Clint Talbert <>
# Henrik Skupin <>
# Alternatively, the contents of this file may be used under the terms of
# either the GNU General Public License Version 2 or later (the "GPL"), or
# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
# in which case the provisions of the GPL or the LGPL are applicable instead
# of those above. If you wish to allow use of your version of this file only
# under the terms of either the GPL or the LGPL, and not to allow others to
# use your version of this file under the terms of the MPL, indicate your
# decision by deleting the provisions above and replace them with the notice
# and other provisions required by the GPL or the LGPL. If you do not delete
# the provisions above, a recipient may use your version of this file under
# the terms of any one of the MPL, the GPL or the LGPL.
# ***** END LICENSE BLOCK *****
import os
import sys
import copy
import tempfile
import signal
import commands
import zipfile
import optparse
import killableprocess
import subprocess
import platform
from distutils import dir_util
from time import sleep
from xml.dom import minidom
# conditional (version-dependent) imports
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 == '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}
if sys.platform != "win32":
return killableprocess.Popen(cmd, preexec_fn=lambda : os.setpgid(0, 0),
env=env, **killable_kwargs)
return killableprocess.Popen(cmd, env=env, **killable_kwargs)
def getoutput(l):
tmp = tempfile.mktemp()
x = open(tmp, 'w'), stdout=x, stderr=x)
x.close(); x = open(tmp, 'r')
r = ; x.close()
return r
def get_pids(name, minimun_pid=0):
"""Get all the pids matching name, exclude any pids below minimum_pid."""
if == 'nt' or sys.platform == 'cygwin':
import wpk
pids = wpk.get_pids(name)
# get_pids_cmd = ['ps', 'ax']
# h = killableprocess.runCommand(get_pids_cmd, stdout=subprocess.PIPE, universal_newlines=True)
# h.wait(group=False)
# data = h.stdout.readlines()
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 kill_process_by_name(name):
"""Find and kill all processes containing a certain name"""
pids = get_pids(name)
if == 'nt' or sys.platform == 'cygwin':
for p in pids:
import wpk
for pid in pids:
os.kill(pid, signal.SIGTERM)
except OSError: pass
if len(get_pids(name)) is not 0:
os.kill(pid, signal.SIGKILL)
except OSError: pass
if len(get_pids(name)) is not 0:
logger.error('Could not kill process')
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):
except OSError, e:
if tail == os.curdir: # xxx/newdir/. exists if xxx/newdir exists
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,
self.binary = binary
self.create_new = not(bool(profile))
if profile:
self.profile = profile
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()
self.preferences = {}
for addon in self.addons:
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
### methods related to addons
def addon_id(self, addon_path):
return the id for a given addon, or None if not found
- addon_path : path to the addon directory
def find_id(desc):
"""finds the addon id give its description"""
addon_id = None
for elem in desc:
apps = elem.getElementsByTagName('em:targetApplication')
if apps:
for app in apps:
# remove targetApplication nodes, they contain id's we aren't interested in
if elem.getElementsByTagName('em:id'):
addon_id = str(elem.getElementsByTagName('em:id')[0]
elif elem.hasAttribute('em:id'):
addon_id = str(elem.getAttribute('em:id'))
return addon_id
doc = minidom.parse(os.path.join(addon_path, 'install.rdf'))
for tag in 'Description', 'RDF:Description':
desc = doc.getElementsByTagName(tag)
addon_id = find_id(desc)
if addon_id:
return addon_id
def install_addon(self, path):
"""Installs the given addon or directory of addons in the profile."""
# if the addon is a directory, install all addons in it
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)]
# install each addon
for addon in addons:
# if the addon is an .xpi, uncompress it to a temporary directory
if addon.endswith('.xpi'):
tmpdir = tempfile.mkdtemp(suffix = "." + os.path.split(addon)[-1])
compressed_file = zipfile.ZipFile(addon, "r")
for name in compressed_file.namelist():
if name.endswith('/'):
makedirs(os.path.join(tmpdir, name))
if not os.path.isdir(os.path.dirname(os.path.join(tmpdir, name))):
makedirs(os.path.dirname(os.path.join(tmpdir, name)))
data =
f = open(os.path.join(tmpdir, name), 'wb')
f.write(data) ; f.close()
addon = tmpdir
# determine the addon id
addon_id = Profile.addon_id(addon)
assert addon_id is not None, "The addon id could not be found: %s" % addon
# copy the addon to the profile
addon_path = os.path.join(self.profile, 'extensions', addon_id)
copytree(addon, addon_path, preserve_symlinks=1)
def clean_addons(self):
"""Cleans up addons in the profile."""
for addon in self.addons_installed:
if os.path.isdir(addon):
### methods related to preferences
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+')
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
for line in pref_lines:
f.write('#MozRunner Prefs End\n')
f.flush() ; f.close()
def clean_preferences(self):
"""Removed preferences added by mozrunner."""
lines = open(os.path.join(self.profile, 'user.js'), 'r').read().splitlines()
s = lines.index('#MozRunner Prefs Start') ; e = lines.index('#MozRunner Prefs End')
cleaned_prefs = '\n'.join(lines[:s] + lines[e+1:])
f = open(os.path.join(self.profile, 'user.js'), 'w')
f.write(cleaned_prefs) ; f.flush() ; f.close()
### cleanup
def cleanup(self):
"""Cleanup operations on the profile."""
if self.create_new:
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
'' : 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,
# Dont' run the add-on compatibility check during start-up
'extensions.showMismatchUI' : False,
# 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,
def names(self):
if sys.platform == 'darwin':
return ['firefox', 'minefield', 'shiretoko']
if (sys.platform == 'linux2') or (sys.platform in ('sunos5', 'solaris')):
return ['firefox', 'mozilla-firefox', 'iceweasel']
if == 'nt' or sys.platform == 'cygwin':
return ['firefox']
class ThunderbirdProfile(Profile):
preferences = {'extensions.update.enabled' : False,
'extensions.update.notifyUser' : False,
'' : False,
'browser.tabs.warnOnClose' : False,
'browser.warnOnQuit': False,
'browser.sessionstore.resume_from_crash': False,
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,
aggressively_kill=['crashreporter'], 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])
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)
os.environ['LD_LIBRARY_PATH'] = dirname
self.profile = profile
self.cmdargs = cmdargs
if env is None:
self.env = copy.copy(os.environ)
self.env = env
self.aggressively_kill = aggressively_kill
self.kp_kwargs = kp_kwargs
def find_binary(self):
"""Finds the binary for self.names if one was not provided."""
binary = None
if sys.platform in ('linux2', 'sunos5', 'solaris'):
for name in reversed(self.names):
binary = findInPath(name)
elif == 'nt' or sys.platform == 'cygwin':
# find the default executable from the windows registry
# assumes self.app_name is defined, as it should be for
# implementors
import _winreg
app_key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, r"Software\Mozilla\Mozilla %s" % self.app_name)
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: # XXX not sure what type of exception this should be
# 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']
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,'Minefield', 'firefox.exe'),
(os.environ.get("ProgramFiles(x86)"),'Minefield', 'firefox.exe')
path = os.path.join(*bin)
if os.path.isfile(path):
binary = path
elif sys.platform == 'darwin':
for name in reversed(self.names):
appdir = os.path.join('Applications', name.capitalize()+'.app')
if os.path.isdir(os.path.join(os.path.expanduser('~/'), appdir)):
binary = os.path.join(os.path.expanduser('~/'), appdir,
elif os.path.isdir('/'+appdir):
binary = os.path.join("/"+appdir, 'Contents/MacOS/'+name+'-bin')
if binary is not None:
if not os.path.isfile(binary):
binary = binary.replace(name+'-bin', 'firefox-bin')
if not os.path.isfile(binary):
binary = None
if binary is None:
raise Exception('Mozrunner could not locate your binary, you will need to set it.')
return binary
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, '%s.ini' % file))
for entry in [['SourceRepository', 'repository'], ['SourceStamp', 'changeset']]:
(key, id) = entry
repository['%s_%s' % (file, id)] = config.get(section, key);
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."""
if sys.platform != 'win32':
for name in self.names:
for pid in get_pids(name, = pid
def kill(self, kill_signal=signal.SIGTERM):
"""Kill the browser"""
if sys.platform != 'win32':
for name in self.names:
for pid in get_pids(name, = pid
except Exception, e:
logger.error('Cannot kill process, '+type(e).__name__+' '+e.message)
for name in self.aggressively_kill:
def stop(self):
class FirefoxRunner(Runner):
"""Specialized Runner subclass for running Firefox."""
app_name = 'Firefox'
profile_class = FirefoxProfile
def names(self):
if sys.platform == 'darwin':
return ['firefox', 'minefield', 'shiretoko']
if (sys.platform == 'linux2') or (sys.platform in ('sunos5', 'solaris')):
return ['firefox', 'mozilla-firefox', 'iceweasel']
if == 'nt' or sys.platform == 'cygwin':
return ['firefox']
class ThunderbirdRunner(Runner):
"""Specialized Runner subclass for running Thunderbird"""
app_name = 'Thunderbird'
profile_class = ThunderbirdProfile
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,
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()
# XXX should use action='append' instead of rolling our own
self.addons = self.options.addons.split(',')
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,
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()
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."""
print 'Started:', ' '.join(runner.command)
except KeyboardInterrupt:
def cli():
def print_addon_ids(args=sys.argv[1:]):
"""print addon ids for testing"""
for arg in args:
print Profile.addon_id(arg)