gecko-dev/testing/mozbase/setup_development.py
2014-02-19 16:42:01 -05:00

261 lines
9.0 KiB
Python
Executable File

#!/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/.
"""
Setup mozbase packages for development.
Packages may be specified as command line arguments.
If no arguments are given, install all packages.
See https://wiki.mozilla.org/Auto-tools/Projects/Mozbase
"""
import os
import subprocess
import sys
from optparse import OptionParser
from subprocess import PIPE
try:
from subprocess import check_call as call
except ImportError:
from subprocess import call
# directory containing this file
here = os.path.dirname(os.path.abspath(__file__))
# all python packages
mozbase_packages = [i for i in os.listdir(here)
if os.path.exists(os.path.join(here, i, 'setup.py'))]
test_packages = [ "mock" # testing: https://wiki.mozilla.org/Auto-tools/Projects/Mozbase#Tests
]
extra_packages = [ "sphinx" # documentation: https://wiki.mozilla.org/Auto-tools/Projects/Mozbase#Documentation
]
def cycle_check(order, dependencies):
"""ensure no cyclic dependencies"""
order_dict = dict([(j, i) for i, j in enumerate(order)])
for package, deps in dependencies.items():
index = order_dict[package]
for d in deps:
assert index > order_dict[d], "Cyclic dependencies detected"
def info(directory):
"get the package setup.py information"
assert os.path.exists(os.path.join(directory, 'setup.py'))
# setup the egg info
try:
call([sys.executable, 'setup.py', 'egg_info'], cwd=directory, stdout=PIPE)
except subprocess.CalledProcessError:
print "Error running setup.py in %s" % directory
raise
# get the .egg-info directory
egg_info = [entry for entry in os.listdir(directory)
if entry.endswith('.egg-info')]
assert len(egg_info) == 1, 'Expected one .egg-info directory in %s, got: %s' % (directory, egg_info)
egg_info = os.path.join(directory, egg_info[0])
assert os.path.isdir(egg_info), "%s is not a directory" % egg_info
# read the package information
pkg_info = os.path.join(egg_info, 'PKG-INFO')
info_dict = {}
for line in file(pkg_info).readlines():
if not line or line[0].isspace():
continue # XXX neglects description
assert ':' in line
key, value = [i.strip() for i in line.split(':', 1)]
info_dict[key] = value
return info_dict
def get_dependencies(directory):
"returns the package name and dependencies given a package directory"
# get the package metadata
info_dict = info(directory)
# get the .egg-info directory
egg_info = [entry for entry in os.listdir(directory)
if entry.endswith('.egg-info')][0]
# read the dependencies
requires = os.path.join(directory, egg_info, 'requires.txt')
if os.path.exists(requires):
dependencies = [line.strip()
for line in file(requires).readlines()
if line.strip()]
else:
dependencies = []
# return the information
return info_dict['Name'], dependencies
def dependency_info(dep):
"return dictionary of dependency information from a dependency string"
retval = dict(Name=None, Type=None, Version=None)
for joiner in ('==', '<=', '>='):
if joiner in dep:
retval['Type'] = joiner
name, version = [i.strip() for i in dep.split(joiner, 1)]
retval['Name'] = name
retval['Version'] = version
break
else:
retval['Name'] = dep.strip()
return retval
def unroll_dependencies(dependencies):
"""
unroll a set of dependencies to a flat list
dependencies = {'packageA': set(['packageB', 'packageC', 'packageF']),
'packageB': set(['packageC', 'packageD', 'packageE', 'packageG']),
'packageC': set(['packageE']),
'packageE': set(['packageF', 'packageG']),
'packageF': set(['packageG']),
'packageX': set(['packageA', 'packageG'])}
"""
order = []
# flatten all
packages = set(dependencies.keys())
for deps in dependencies.values():
packages.update(deps)
while len(order) != len(packages):
for package in packages.difference(order):
if set(dependencies.get(package, set())).issubset(order):
order.append(package)
break
else:
raise AssertionError("Cyclic dependencies detected")
cycle_check(order, dependencies) # sanity check
return order
def main(args=sys.argv[1:]):
# parse command line options
usage = '%prog [options] [package] [package] [...]'
parser = OptionParser(usage=usage, description=__doc__)
parser.add_option('-d', '--dependencies', dest='list_dependencies',
action='store_true', default=False,
help="list dependencies for the packages")
parser.add_option('--list', action='store_true', default=False,
help="list what will be installed")
parser.add_option('--extra', '--install-extra-packages', action='store_true', default=False,
help="installs extra supporting packages as well as core mozbase ones")
options, packages = parser.parse_args(args)
if not packages:
# install all packages
packages = sorted(mozbase_packages)
# ensure specified packages are in the list
assert set(packages).issubset(mozbase_packages), "Packages should be in %s (You gave: %s)" % (mozbase_packages, packages)
if options.list_dependencies:
# list the package dependencies
for package in packages:
print '%s: %s' % get_dependencies(os.path.join(here, package))
parser.exit()
# gather dependencies
# TODO: version conflict checking
deps = {}
alldeps = {}
mapping = {} # mapping from subdir name to package name
# core dependencies
for package in packages:
key, value = get_dependencies(os.path.join(here, package))
deps[key] = [dependency_info(dep)['Name'] for dep in value]
mapping[package] = key
# keep track of all dependencies for non-mozbase packages
for dep in value:
alldeps[dependency_info(dep)['Name']] = ''.join(dep.split())
# indirect dependencies
flag = True
while flag:
flag = False
for value in deps.values():
for dep in value:
if dep in mozbase_packages and dep not in deps:
key, value = get_dependencies(os.path.join(here, dep))
deps[key] = [sanitize_dependency(dep) for dep in value]
for dep in value:
alldeps[sanitize_dependency(dep)] = ''.join(dep.split())
mapping[package] = key
flag = True
break
if flag:
break
# get the remaining names for the mapping
for package in mozbase_packages:
if package in mapping:
continue
key, value = get_dependencies(os.path.join(here, package))
mapping[package] = key
# unroll dependencies
unrolled = unroll_dependencies(deps)
# make a reverse mapping: package name -> subdirectory
reverse_mapping = dict([(j,i) for i, j in mapping.items()])
# we only care about dependencies in mozbase
unrolled = [package for package in unrolled if package in reverse_mapping]
if options.list:
# list what will be installed
for package in unrolled:
print package
parser.exit()
# set up the packages for development
for package in unrolled:
call([sys.executable, 'setup.py', 'develop', '--no-deps'],
cwd=os.path.join(here, reverse_mapping[package]))
# add the directory of sys.executable to path to aid the correct
# `easy_install` getting called
# https://bugzilla.mozilla.org/show_bug.cgi?id=893878
os.environ['PATH'] = '%s%s%s' % (os.path.dirname(os.path.abspath(sys.executable)),
os.path.pathsep,
os.environ.get('PATH', '').strip(os.path.pathsep))
# install non-mozbase dependencies
# these need to be installed separately and the --no-deps flag
# subsequently used due to a bug in setuptools; see
# https://bugzilla.mozilla.org/show_bug.cgi?id=759836
pypi_deps = dict([(i, j) for i,j in alldeps.items()
if i not in unrolled])
for package, version in pypi_deps.items():
# easy_install should be available since we rely on setuptools
call(['easy_install', version])
# install packages required for unit testing
for package in test_packages:
call(['easy_install', package])
# install extra non-mozbase packages if desired
if options.extra:
for package in extra_packages:
call(['easy_install', package])
if __name__ == '__main__':
main()