X-Git-Url: https://git.rkrishnan.org/?a=blobdiff_plain;f=setup.py;h=63697e004a4c7113b18d6733d8a7973719e97c72;hb=HEAD;hp=7f10422bfd1812c74c29ad03cf99a5425d4f475c;hpb=d3b78d86cadb8fcd27fbc7449d8d504cba945633;p=tahoe-lafs%2Ftahoe-lafs.git diff --git a/setup.py b/setup.py index 7f10422b..63697e00 100644 --- a/setup.py +++ b/setup.py @@ -1,14 +1,16 @@ #! /usr/bin/env python +# -*- coding: utf-8 -*- +import sys; assert sys.version_info < (3,), ur"Tahoe-LAFS does not run under Python 3. Please use Python 2.7.x." -# Allmydata Tahoe -- secure, distributed storage grid +# Tahoe-LAFS -- secure, distributed storage grid # -# Copyright (C) 2008 Allmydata, Inc. +# Copyright © 2006-2012 The Tahoe-LAFS Software Foundation # -# This file is part of tahoe. +# This file is part of Tahoe-LAFS. # -# See the docs/about.html file for licensing information. +# See the docs/about.rst file for licensing information. -import os, re, shutil, stat, subprocess, sys, zipfile +import os, stat, subprocess, re ##### sys.path management @@ -22,60 +24,61 @@ def pylibdir(prefixdir): basedir = os.path.dirname(os.path.abspath(__file__)) supportlib = pylibdir(os.path.join(basedir, "support")) +# locate our version number -for i in range(len(sys.argv)): - arg = sys.argv[i] - prefixdir = None - if arg.startswith("--prefix="): - prefixdir = arg[len("--prefix="):] - if arg == "--prefix": - if len(sys.argv) > i+1: - prefixdir = sys.argv[i+1] +def read_version_py(infname): + try: + verstrline = open(infname, "rt").read() + except EnvironmentError: + return None + else: + VSRE = r"^verstr = ['\"]([^'\"]*)['\"]" + mo = re.search(VSRE, verstrline, re.M) + if mo: + return mo.group(1) - if prefixdir: - libdir = pylibdir(prefixdir) - try: - os.makedirs(libdir) - except EnvironmentError, le: - # Okay, maybe the dir was already there. - pass - sys.path.append(libdir) - pp = os.environ.get('PYTHONPATH','').split(os.pathsep) - pp.append(libdir) - os.environ['PYTHONPATH'] = os.pathsep.join(pp) - - if arg.startswith("develop") or arg.startswith("build") or arg.startswith("test"): # argh! horrible kludge to workaround setuptools #17 - if sys.platform == "linux2": - # workaround for tahoe #229 / setuptools #17, on debian - sys.argv.extend(["--site-dirs", "/var/lib/python-support/python%d.%d" % (sys.version_info[:2])]) - elif sys.platform == "darwin": - # this probably only applies to leopard 10.5, possibly only 10.5.5 - sd = "/System/Library/Frameworks/Python.framework/Versions/%d.%d/Extras/lib/python" % (sys.version_info[:2]) - sys.argv.extend(["--site-dirs", sd]) +VERSION_PY_FILENAME = 'src/allmydata/_version.py' +version = read_version_py(VERSION_PY_FILENAME) +APPNAME='allmydata-tahoe' +APPNAMEFILE = os.path.join('src', 'allmydata', '_appname.py') +APPNAMEFILESTR = "__appname__ = '%s'" % (APPNAME,) try: - from ez_setup import use_setuptools -except ImportError: - pass + curappnamefilestr = open(APPNAMEFILE, 'rU').read() +except EnvironmentError: + # No file, or unreadable or something, okay then let's try to write one. + open(APPNAMEFILE, "w").write(APPNAMEFILESTR) else: - # This invokes our own customized version of ez_setup.py to make sure that - # setuptools >= v0.6c8 (a.k.a. v0.6-final) is installed. + if curappnamefilestr.strip() != APPNAMEFILESTR: + print("Error -- this setup.py file is configured with the 'application name' to be '%s', but there is already a file in place in '%s' which contains the contents '%s'. If the file is wrong, please remove it and setup.py will regenerate it and write '%s' into it." % (APPNAME, APPNAMEFILE, curappnamefilestr, APPNAMEFILESTR)) + sys.exit(-1) - # setuptools < v0.6c8 doesn't handle eggs which get installed into the CWD - # as a result of being transitively depended on in a setup_requires, but - # then are needed for the installed code to run, i.e. in an - # install_requires. - use_setuptools(download_delay=0, min_version="0.6c10dev") +# setuptools/zetuptoolz looks in __main__.__requires__ for a list of +# requirements. When running "python setup.py test", __main__ is +# setup.py, so we put the list here so that the requirements will be +# available for tests: -from setuptools import find_packages, setup -from setuptools.command import sdist -from distutils.core import Command -from pkg_resources import require +# Tahoe's dependencies are managed by the find_links= entry in setup.cfg and +# the _auto_deps.install_requires list, which is used in the call to setup() +# below. +adglobals = {} +execfile('src/allmydata/_auto_deps.py', adglobals) +install_requires = adglobals['install_requires'] +setup_requires = adglobals['setup_requires'] + +if len(sys.argv) > 1 and sys.argv[1] == '--fakedependency': + del sys.argv[1] + install_requires += ["fakedependency >= 1.0.0"] + +__requires__ = install_requires[:] -# Make the dependency-version-requirement, which is used by the Makefile at -# build-time, also available to the app at runtime: -import shutil -shutil.copyfile("_auto_deps.py", os.path.join("src", "allmydata", "_auto_deps.py")) +egg = os.path.realpath('setuptools-0.6c16dev6.egg') +sys.path.insert(0, egg) +import setuptools; setuptools.bootstrap_install_from = egg + +from setuptools import setup +from setuptools.command import sdist +from setuptools import Command trove_classifiers=[ "Development Status :: 5 - Production/Stable", @@ -89,7 +92,6 @@ trove_classifiers=[ "Intended Audience :: System Administrators", "Operating System :: Microsoft", "Operating System :: Microsoft :: Windows", - "Operating System :: Microsoft :: Windows :: Windows NT/2000", "Operating System :: Unix", "Operating System :: POSIX :: Linux", "Operating System :: POSIX", @@ -99,157 +101,91 @@ trove_classifiers=[ "Programming Language :: C", "Programming Language :: Python", "Programming Language :: Python :: 2", - "Programming Language :: Python :: 2.4", - "Programming Language :: Python :: 2.5", - "Programming Language :: Python :: 2.6", + "Programming Language :: Python :: 2.7", "Topic :: Utilities", "Topic :: System :: Systems Administration", "Topic :: System :: Filesystems", "Topic :: System :: Distributed Computing", "Topic :: Software Development :: Libraries", - "Topic :: Communications :: Usenet News", "Topic :: System :: Archiving :: Backup", "Topic :: System :: Archiving :: Mirroring", "Topic :: System :: Archiving", ] -VERSIONFILE = "src/allmydata/_version.py" -verstr = "unknown" -try: - verstrline = open(VERSIONFILE, "rt").read() -except EnvironmentError: - pass # Okay, there is no version file. -else: - VSRE = r"^verstr = ['\"]([^'\"]*)['\"]" - mo = re.search(VSRE, verstrline, re.M) - if mo: - verstr = mo.group(1) - else: - print "unable to find version in %s" % (VERSIONFILE,) - raise RuntimeError("if %s.py exists, it is required to be well-formed" % (VERSIONFILE,)) - -LONG_DESCRIPTION=\ -"""Welcome to the Tahoe project, a secure, decentralized, fault-tolerant -filesystem. All of the source code is available under a Free Software, Open -Source licence. - -This filesystem is encrypted and spread over multiple peers in such a way that -it remains available even when some of the peers are unavailable, -malfunctioning, or malicious.""" - - -setup_requires = [] - -# Nevow requires Twisted to setup, but doesn't declare that requirement in a way that enables -# setuptools to satisfy that requirement before Nevow's setup.py tried to "import twisted". -# Fortunately we require setuptools_trial to setup and setuptools_trial requires Twisted to -# install, so hopefully everything will work out until the Nevow issue is fixed: -# http://divmod.org/trac/ticket/2629 -# setuptools_trial is needed if you want "./setup.py trial" or "./setup.py test" to execute the -# tests (and in order to make sure Twisted is installed early enough -- see the paragraph -# above). -# http://pypi.python.org/pypi/setuptools_trial -setup_requires.extend(['setuptools_trial']) - -# darcsver is needed if you want "./setup.py darcsver" to write a new version stamp in -# src/allmydata/_version.py, with a version number derived from darcs history. -# http://pypi.python.org/pypi/darcsver -setup_requires.append('darcsver >= 1.1.5') - -if 'trial' in sys.argv[1:] or 'test' in sys.argv[1:]: - # Cygwin requires the poll reactor to work at all. Linux requires the poll reactor to avoid - # bug #402 (twisted bug #3218). In general, the poll reactor is better than the select - # reactor, but it is not available on all platforms. According to exarkun on IRC, it is - # available but buggy on some versions of Mac OS X, so just because you can install it - # doesn't mean we want to use it on every platform. - if sys.platform in ("linux2", "cygwin"): - if not [a for a in sys.argv if a.startswith("--reactor")]: - sys.argv.append("--reactor=poll") - -# setuptools_darcs is required to produce complete distributions (such as with -# "sdist" or "bdist_egg"), unless there is a PKG-INFO file present which shows -# that this is itself a source distribution. -# http://pypi.python.org/pypi/setuptools_darcs -if not os.path.exists('PKG-INFO'): - setup_requires.append('setuptools_darcs >= 1.1.0') - -class ShowSupportLib(Command): - user_options = [] - def initialize_options(self): - pass - def finalize_options(self): - pass - def run(self): - # TODO: --quiet suppresses the 'running show_supportlib' message. - # Find a way to do this all the time. - print supportlib # TODO windowsy - -class ShowPythonPath(Command): - user_options = [] - def initialize_options(self): - pass - def finalize_options(self): - pass - def run(self): - # TODO: --quiet suppresses the 'running show_supportlib' message. - # Find a way to do this all the time. - print "PYTHONPATH=%s" % os.environ.get("PYTHONPATH", '') +# We no longer have any requirements specific to tests. +tests_require=[] -class RunWithPythonPath(Command): - description = "Run a subcommand with PYTHONPATH set appropriately" - user_options = [ ("python", "p", - "Treat command string as arguments to a python executable"), - ("command=", "c", "Command to be run"), - ("directory=", "d", "Directory to run the command in"), - ] - boolean_options = ["python"] +class Trial(Command): + description = "run trial (use 'bin%stahoe debug trial' for the full set of trial options)" % (os.sep,) + # This is just a subset of the most useful options, for compatibility. + user_options = [ ("no-rterrors", None, "Don't print out tracebacks as they occur."), + ("rterrors", "e", "Print out tracebacks as they occur (default, so ignored)."), + ("until-failure", "u", "Repeat a test (specified by -s) until it fails."), + ("reporter=", None, "The reporter to use for this test run."), + ("suite=", "s", "Specify the test suite."), + ("quiet", None, "Don't display version numbers and paths of Tahoe dependencies."), + ("coverage", "c", "Collect branch coverage information."), + ] def initialize_options(self): - self.command = None - self.python = False - self.directory = None - def finalize_options(self): - pass - def run(self): - oldpp = os.environ.get("PYTHONPATH", "").split(os.pathsep) - if oldpp == [""]: - # grr silly split() behavior - oldpp = [] - os.environ['PYTHONPATH'] = os.pathsep.join(oldpp + [supportlib,]) - - # We must require the command to be safe to split on - # whitespace, and have --python and --directory to make it - # easier to achieve this. - - command = [] - if self.python: - command.append(sys.executable) - if self.command: - command.extend(self.command.split()) - if not command: - raise RuntimeError("The --command argument is mandatory") - if self.directory: - os.chdir(self.directory) - if self.verbose: - print "command =", " ".join(command) - rc = subprocess.call(command) - sys.exit(rc) + self.rterrors = False + self.no_rterrors = False + self.until_failure = False + self.reporter = None + self.suite = "allmydata" + self.quiet = False + self.coverage = False -class CheckAutoDeps(Command): - user_options = [] - def initialize_options(self): - pass def finalize_options(self): pass + def run(self): - import _auto_deps - _auto_deps.require_auto_deps() + args = [sys.executable, os.path.join('bin', 'tahoe')] + + if self.coverage: + from errno import ENOENT + coverage_cmd = 'coverage' + try: + subprocess.call([coverage_cmd, 'help']) + except OSError as e: + if e.errno != ENOENT: + raise + coverage_cmd = 'python-coverage' + try: + rc = subprocess.call([coverage_cmd, 'help']) + except OSError as e: + if e.errno != ENOENT: + raise + print >>sys.stderr + print >>sys.stderr, "Couldn't find the command 'coverage' nor 'python-coverage'." + print >>sys.stderr, "coverage can be installed using 'pip install coverage', or on Debian-based systems, 'apt-get install python-coverage'." + sys.exit(1) + + args += ['@' + coverage_cmd, 'run', '--branch', '--source=src/allmydata', '@tahoe'] + + if not self.quiet: + args.append('--version-and-path') + args += ['debug', 'trial'] + if self.rterrors and self.no_rterrors: + raise AssertionError("--rterrors and --no-rterrors conflict.") + if not self.no_rterrors: + args.append('--rterrors') + if self.until_failure: + args.append('--until-failure') + if self.reporter: + args.append('--reporter=' + self.reporter) + if self.suite: + args.append(self.suite) + rc = subprocess.call(args) + sys.exit(rc) class MakeExecutable(Command): + description = "make the 'bin%stahoe' scripts" % (os.sep,) user_options = [] + def initialize_options(self): pass def finalize_options(self): @@ -257,51 +193,175 @@ class MakeExecutable(Command): def run(self): bin_tahoe_template = os.path.join("bin", "tahoe-script.template") - # Create the 'tahoe-script.py' file under the 'bin' directory. The 'tahoe-script.py' - # file is exactly the same as the 'tahoe-script.template' script except that the shebang - # line is rewritten to use our sys.executable for the interpreter. On Windows, create a - # tahoe.exe will execute it. On non-Windows, make a symlink to it from 'tahoe'. The - # tahoe.exe will be copied from the setuptools egg's cli.exe and this will work from a - # zip-safe and non-zip-safe setuptools egg. + # tahoe.pyscript is really only necessary for Windows, but we also + # create it on Unix for consistency. + script_names = ["tahoe.pyscript", "tahoe"] + + # Create the tahoe script file under the 'bin' directory. This + # file is exactly the same as the 'tahoe-script.template' script + # except that the shebang line is rewritten to use our sys.executable + # for the interpreter. f = open(bin_tahoe_template, "rU") script_lines = f.readlines() f.close() - script_lines[0] = "#!%s\n" % sys.executable - tahoe_script = os.path.join("bin", "tahoe-script.py") - f = open(tahoe_script, "w") - for line in script_lines: - f.write(line) - f.close() - if sys.platform == "win32": - setuptools_egg = require("setuptools")[0].location - if os.path.isfile(setuptools_egg): - z = zipfile.ZipFile(setuptools_egg, 'r') - for filename in z.namelist(): - if 'cli.exe' in filename: - cli_exe = z.read(filename) - else: - cli_exe = os.path.join(setuptools_egg, 'setuptools', 'cli.exe') - tahoe_exe = os.path.join("bin", "tahoe.exe") - if os.path.isfile(setuptools_egg): - f = open(tahoe_exe, 'wb') - f.write(cli_exe) - f.close() - else: - shutil.copy(cli_exe, tahoe_exe) - else: + script_lines[0] = '#!%s\n' % (sys.executable,) + for script_name in script_names: + tahoe_script = os.path.join("bin", script_name) try: - os.remove(os.path.join('bin', 'tahoe')) - except: - # okay, probably it was already gone - pass - os.symlink('tahoe-script.py', os.path.join('bin', 'tahoe')) - - # chmod +x bin/tahoe-script.py - old_mode = stat.S_IMODE(os.stat(tahoe_script)[stat.ST_MODE]) + os.remove(tahoe_script) + except Exception: + if os.path.exists(tahoe_script): + raise + f = open(tahoe_script, "wb") + for line in script_lines: + f.write(line) + f.close() + + # chmod +x + unix_script = os.path.join("bin", "tahoe") + old_mode = stat.S_IMODE(os.stat(unix_script)[stat.ST_MODE]) new_mode = old_mode | (stat.S_IXUSR | stat.S_IRUSR | stat.S_IXGRP | stat.S_IRGRP | stat.S_IXOTH | stat.S_IROTH ) - os.chmod(tahoe_script, new_mode) + os.chmod(unix_script, new_mode) + + old_tahoe_exe = os.path.join("bin", "tahoe.exe") + try: + os.remove(old_tahoe_exe) + except Exception: + if os.path.exists(old_tahoe_exe): + raise + + +GIT_VERSION_BODY = ''' +# This _version.py is generated from git metadata by the tahoe setup.py. + +__pkgname__ = %(pkgname)r +real_version = %(version)r +full_version = %(full)r +branch = %(branch)r +verstr = %(normalized)r +__version__ = verstr +''' + +def run_command(args, cwd=None): + use_shell = sys.platform == "win32" + try: + p = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd, shell=use_shell) + except EnvironmentError as e: # if this gives a SyntaxError, note that Tahoe-LAFS requires Python 2.7+ + print("Warning: unable to run %r." % (" ".join(args),)) + print(e) + return None + stdout = p.communicate()[0].strip() + if p.returncode != 0: + print("Warning: %r returned error code %r." % (" ".join(args), p.returncode)) + return None + return stdout + + +def versions_from_git(tag_prefix): + # This runs 'git' from the directory that contains this file. That either + # means someone ran a setup.py command (and this code is in + # versioneer.py, thus the containing directory is the root of the source + # tree), or someone ran a project-specific entry point (and this code is + # in _version.py, thus the containing directory is somewhere deeper in + # the source tree). This only gets called if the git-archive 'subst' + # variables were *not* expanded, and _version.py hasn't already been + # rewritten with a short version string, meaning we're inside a checked + # out source tree. + + # versions_from_git (as copied from python-versioneer) returns strings + # like "1.9.0-25-gb73aba9-dirty", which means we're in a tree with + # uncommited changes (-dirty), the latest checkin is revision b73aba9, + # the most recent tag was 1.9.0, and b73aba9 has 25 commits that weren't + # in 1.9.0 . The narrow-minded NormalizedVersion parser that takes our + # output (meant to enable sorting of version strings) refuses most of + # that. Tahoe uses a function named suggest_normalized_version() that can + # handle "1.9.0.post25", so dumb down our output to match. + + try: + source_dir = os.path.dirname(os.path.abspath(__file__)) + except NameError as e: + # some py2exe/bbfreeze/non-CPython implementations don't do __file__ + print("Warning: unable to find version because we could not obtain the source directory.") + print(e) + return {} + stdout = run_command(["git", "describe", "--tags", "--dirty", "--always"], + cwd=source_dir) + if stdout is None: + # run_command already complained. + return {} + if not stdout.startswith(tag_prefix): + print("Warning: tag %r doesn't start with prefix %r." % (stdout, tag_prefix)) + return {} + version = stdout[len(tag_prefix):] + pieces = version.split("-") + if len(pieces) == 1: + normalized_version = pieces[0] + else: + normalized_version = "%s.post%s" % (pieces[0], pieces[1]) + + stdout = run_command(["git", "rev-parse", "HEAD"], cwd=source_dir) + if stdout is None: + # run_command already complained. + return {} + full = stdout.strip() + if version.endswith("-dirty"): + full += "-dirty" + normalized_version += ".dev0" + + # Thanks to Jistanidiot at . + stdout = run_command(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=source_dir) + branch = (stdout or "unknown").strip() + + return {"version": version, "normalized": normalized_version, "full": full, "branch": branch} + +# setup.cfg has an [aliases] section which runs "update_version" before many +# commands (like "build" and "sdist") that need to know our package version +# ahead of time. If you add different commands (or if we forgot some), you +# may need to add it to setup.cfg and configure it to run update_version +# before your command. + +class UpdateVersion(Command): + description = "update _version.py from revision-control metadata" + user_options = [] + + def initialize_options(self): + pass + def finalize_options(self): + pass + def run(self): + global version + verstr = version + if os.path.isdir(os.path.join(basedir, ".git")): + verstr = self.try_from_git() + + if verstr: + self.distribution.metadata.version = verstr + else: + print("""\ +******************************************************************** +Warning: no version information found. This may cause tests to fail. +******************************************************************** +""") + + def try_from_git(self): + # If we change APPNAME, the release tag names should also change from then on. + versions = versions_from_git(APPNAME + '-') + if versions: + f = open(VERSION_PY_FILENAME, "wb") + f.write(GIT_VERSION_BODY % + { "pkgname": self.distribution.get_name(), + "version": versions["version"], + "normalized": versions["normalized"], + "full": versions["full"], + "branch": versions["branch"], + }) + f.close() + print("Wrote normalized version %r into '%s'" % (versions["normalized"], VERSION_PY_FILENAME)) + + return versions.get("normalized", None) + class MySdist(sdist.sdist): """ A hook in the sdist command so that we can determine whether this the @@ -346,35 +406,55 @@ class MySdist(sdist.sdist): return fullname + "-SUMO" self.distribution.get_fullname = get_fullname - return sdist.sdist.make_distribution(self) - -# Tahoe's dependencies are managed by the find_links= entry in setup.cfg and -# the _auto_deps.install_requires list, which is used in the call to setup() -# at the end of this file -from _auto_deps import install_requires - -setup(name='allmydata-tahoe', - version=verstr, - description='secure, decentralized, fault-tolerant filesystem', - long_description=LONG_DESCRIPTION, - author='the allmydata.org Tahoe project', - author_email='tahoe-dev@allmydata.org', - url='http://allmydata.org/', - license='GNU GPL', - cmdclass={"show_supportlib": ShowSupportLib, - "show_pythonpath": ShowPythonPath, - "run_with_pythonpath": RunWithPythonPath, - "check_auto_deps": CheckAutoDeps, + try: + old_mask = os.umask(int("022", 8)) + return sdist.sdist.make_distribution(self) + finally: + os.umask(old_mask) + + +setup_args = {} +if version: + setup_args["version"] = version + +setup(name=APPNAME, + description='secure, decentralized, fault-tolerant file store', + long_description=open('README.rst', 'rU').read(), + author='the Tahoe-LAFS project', + author_email='tahoe-dev@tahoe-lafs.org', + url='https://tahoe-lafs.org/', + license='GNU GPL', # see README.rst -- there is an alternative licence + cmdclass={"trial": Trial, "make_executable": MakeExecutable, + "update_version": UpdateVersion, "sdist": MySdist, }, package_dir = {'':'src'}, - packages=find_packages("src"), + packages=['allmydata', + 'allmydata.frontends', + 'allmydata.immutable', + 'allmydata.immutable.downloader', + 'allmydata.introducer', + 'allmydata.mutable', + 'allmydata.scripts', + 'allmydata.storage', + 'allmydata.test', + 'allmydata.util', + 'allmydata.web', + 'allmydata.windows', + 'buildtest'], classifiers=trove_classifiers, test_suite="allmydata.test", install_requires=install_requires, - include_package_data=True, + tests_require=tests_require, + package_data={"allmydata.web": ["*.xhtml", + "static/*.js", "static/*.png", "static/*.css", + "static/img/*.png", + "static/css/*.css", + ] + }, setup_requires=setup_requires, entry_points = { 'console_scripts': [ 'tahoe = allmydata.scripts.runner:run' ] }, zip_safe=False, # We prefer unzipped for easier access. + **setup_args )