setup.py

   1 #! /usr/bin/env python
   2
   3 # Allmydata Tahoe -- secure, distributed storage grid
   4 #
   5 # Copyright (C) 2008 Allmydata, Inc.
   6 #
   7 # This file is part of tahoe.
   8 #
   9 # See the docs/about.html file for licensing information.
  10
  11 import os, re, sys, subprocess
  12
  13 ##### sys.path management
  14
  15 basedir = os.path.dirname(os.path.abspath(__file__))
  16 pyver = "python%d.%d" % (sys.version_info[:2])
  17 if sys.platform == "win32":
  18     supportlib = os.path.join("support", "Lib", "site-packages")
  19 else:
  20     supportlib = os.path.join("support", "lib", pyver, "site-packages")
  21 supportlib = os.path.join(basedir, supportlib)
  22
  23 def add_tahoe_paths():
  24     """Modify sys.path and PYTHONPATH to include Tahoe and supporting libraries
  25
  26     The first step towards building Tahoe is to run::
  27
  28       python setup.py build_tahoe
  29
  30     which is the equivalent of::
  31
  32       mkdir -p $(BASEDIR)/support/lib/python2.5/site-packages
  33        (or cygpath equivalent)
  34       setup.py develop --prefix=$(BASEDIR)/support
  35
  36     This installs .eggs for any dependent libraries that aren't already
  37     available on the system, into support/lib/pythonN.N/site-packages (or
  38     support/Lib/site-packages on windows). It also adds an .egg-link for
  39     Tahoe itself into the same directory.
  40
  41     We add this directory to os.environ['PYTHONPATH'], so that any child
  42     processes we spawn will be able to use these packages.
  43
  44     When the setuptools site.py sees that supportlib in PYTHONPATH, it scans
  45     through it for .egg and .egg-link entries, and adds them to sys.path .
  46     Since python has already processed all the site.py files by the time we
  47     get here, we perform this same sort of processing ourselves: this makes
  48     tahoe (and dependency libraries) available to code within setup.py
  49     itself. This is used by the 'setup.py trial' subcommand, which invokes
  50     trial directly rather than spawning a subprocess (this is easier than
  51     locating the 'trial' executable, especially when Twisted was installed as
  52     a dependent library).
  53
  54     We'll need to add these .eggs to sys.path before importing anything that
  55     isn't a part of stdlib. All the directories that we add this way are put
  56     at the start of sys.path, so they will override anything that was present
  57     on the system (and perhaps found lacking by the setuptools requirements
  58     expressed in _auto_deps.py).
  59     """
  60
  61     extra_syspath_items = []
  62     extra_pythonpath_items = []
  63
  64     extra_syspath_items.append(supportlib)
  65     extra_pythonpath_items.append(supportlib)
  66
  67     # Since we use setuptools to populate that directory, there will be a
  68     # number of .egg and .egg-link entries there. Add all of them to
  69     # sys.path, since that what the setuptools site.py would do if it
  70     # encountered them at process start time. Without this step, the rest of
  71     # this process would be unable to use the packages installed there. We
  72     # don't need to add them to PYTHONPATH, since the site.py present there
  73     # will add them when the child process starts up.
  74
  75     if os.path.isdir(supportlib):
  76         for fn in os.listdir(supportlib):
  77             if fn.endswith(".egg"):
  78                 extra_syspath_items.append(os.path.join(supportlib, fn))
  79
  80     # We also add our src/ directory, since that's where all the Tahoe code
  81     # lives. This matches what site.py does when it sees the .egg-link file
  82     # that is written to the support dir by an invocation of our 'setup.py
  83     # develop' command.
  84     extra_syspath_items.append(os.path.join(basedir, "src"))
  85
  86     # and we put an extra copy of everything from PYTHONPATH in front, so
  87     # that it is possible to override the packages that setuptools downloads
  88     # with alternate versions, by doing e.g. "PYTHONPATH=foo python setup.py
  89     # trial"
  90     oldpp = os.environ.get("PYTHONPATH", "").split(os.pathsep)
  91     if oldpp == [""]:
  92         # grr silly split() behavior
  93         oldpp = []
  94     extra_syspath_items = oldpp + extra_syspath_items
  95
  96     sys.path = extra_syspath_items + sys.path
  97
  98     # We also provide it to any child processes we spawn, via
  99     # os.environ["PYTHONPATH"]
 100     os.environ["PYTHONPATH"] = os.pathsep.join(oldpp + extra_pythonpath_items)
 101
 102 # add_tahoe_paths() must be called before use_setuptools() is called. I don't
 103 # know why. If it isn't, then a later pkg_resources.requires(pycryptopp) call
 104 # fails because an old version (in /usr/lib) was already loaded.
 105 add_tahoe_paths()
 106
 107 try:
 108     from ez_setup import use_setuptools
 109 except ImportError:
 110     pass
 111 else:
 112     # This invokes our own customized version of ez_setup.py to make sure that
 113     # setuptools >= v0.6c8 (a.k.a. v0.6-final) is installed.
 114
 115     # setuptools < v0.6c8 doesn't handle eggs which get installed into the CWD
 116     # as a result of being transitively depended on in a setup_requires, but
 117     # then are needed for the installed code to run, i.e. in an
 118     # install_requires.
 119     use_setuptools(download_delay=0, min_version="0.6c8")
 120
 121 from setuptools import Extension, find_packages, setup
 122 from setuptools.command import sdist
 123 from distutils.core import Command
 124
 125 # Make the dependency-version-requirement, which is used by the Makefile at
 126 # build-time, also available to the app at runtime:
 127 import shutil
 128 try:
 129     shutil.copyfile("_auto_deps.py", os.path.join("src", "allmydata", "_auto_deps.py"))
 130 except EnvironmentError:
 131     # Nevermind then -- perhaps it is already in place and in any case we can do
 132     # without it.
 133     pass
 134
 135 trove_classifiers=[
 136     "Development Status :: 5 - Production/Stable",
 137     "Environment :: Console",
 138     "Environment :: Web Environment",
 139     "License :: OSI Approved :: GNU General Public License (GPL)",
 140     "License :: DFSG approved",
 141     "License :: Other/Proprietary License",
 142     "Intended Audience :: Developers",
 143     "Intended Audience :: End Users/Desktop",
 144     "Intended Audience :: System Administrators",
 145     "Operating System :: Microsoft",
 146     "Operating System :: Microsoft :: Windows",
 147     "Operating System :: Unix",
 148     "Operating System :: POSIX :: Linux",
 149     "Operating System :: POSIX",
 150     "Operating System :: MacOS :: MacOS X",
 151     "Operating System :: Microsoft :: Windows :: Windows NT/2000",
 152     "Operating System :: OS Independent",
 153     "Natural Language :: English",
 154     "Programming Language :: C",
 155     "Programming Language :: Python",
 156     "Topic :: Utilities",
 157     "Topic :: System :: Systems Administration",
 158     "Topic :: System :: Filesystems",
 159     "Topic :: System :: Distributed Computing",
 160     "Topic :: Software Development :: Libraries",
 161     "Topic :: Communications :: Usenet News",
 162     "Topic :: System :: Archiving :: Backup",
 163     "Topic :: System :: Archiving :: Mirroring",
 164     "Topic :: System :: Archiving",
 165     ]
 166
 167
 168 VERSIONFILE = "src/allmydata/_version.py"
 169 verstr = "unknown"
 170 try:
 171     verstrline = open(VERSIONFILE, "rt").read()
 172 except EnvironmentError:
 173     pass # Okay, there is no version file.
 174 else:
 175     VSRE = r"^verstr = ['\"]([^'\"]*)['\"]"
 176     mo = re.search(VSRE, verstrline, re.M)
 177     if mo:
 178         verstr = mo.group(1)
 179     else:
 180         print "unable to find version in %s" % (VERSIONFILE,)
 181         raise RuntimeError("if %s.py exists, it is required to be well-formed" % (VERSIONFILE,))
 182
 183 LONG_DESCRIPTION=\
 184 """Welcome to the Tahoe project, a secure, decentralized, fault-tolerant
 185 filesystem.  All of the source code is available under a Free Software, Open
 186 Source licence.
 187
 188 This filesystem is encrypted and spread over multiple peers in such a way that
 189 it remains available even when some of the peers are unavailable,
 190 malfunctioning, or malicious."""
 191
 192 # For Desert Island builds, assume that the user has extracted the dependency
 193 # tarball into a directory named 'misc/dependencies'.
 194 dependency_links=[os.path.join(os.getcwd(), 'misc', 'dependencies')]
 195
 196 # By adding a web page to the dependency_links we are able to put new packages
 197 # up there and have them be automatically discovered by existing copies of the
 198 # tahoe source when that source was built.
 199 dependency_links.append("http://allmydata.org/trac/tahoe/wiki/Dependencies")
 200
 201 # Default setup_requires are pyutil for the Windows installer builder(see
 202 # misc/sub-ver.py) and Twisted for the tests.
 203 #setup_requires = ['pyutil >= 1.3.16', 'Twisted >= 2.4.0']
 204 setup_requires = []
 205 # darcsver is needed only if you want "./setup.py darcsver" to write a new
 206 # version stamp in src/allmydata/_version.py, with a version number derived from
 207 # darcs history.
 208 # http://pypi.python.org/pypi/darcsver
 209 if 'darcsver' in sys.argv[1:]:
 210     setup_requires.append('darcsver >= 1.1.5')
 211
 212 # setuptools_darcs is required to produce complete distributions (such as with
 213 # "sdist" or "bdist_egg"), unless there is a PKG-INFO file present which shows
 214 # that this is itself a source distribution.
 215 # http://pypi.python.org/pypi/setuptools_darcs
 216 if not os.path.exists('PKG-INFO'):
 217     setup_requires.append('setuptools_darcs >= 1.1.0')
 218
 219 class ShowSupportLib(Command):
 220     user_options = []
 221     def initialize_options(self):
 222         pass
 223     def finalize_options(self):
 224         pass
 225     def run(self):
 226         # TODO: --quiet suppresses the 'running show_supportlib' message.
 227         # Find a way to do this all the time.
 228         print supportlib # TODO windowsy
 229
 230 class ShowPythonPath(Command):
 231     user_options = []
 232     def initialize_options(self):
 233         pass
 234     def finalize_options(self):
 235         pass
 236     def run(self):
 237         # TODO: --quiet suppresses the 'running show_supportlib' message.
 238         # Find a way to do this all the time.
 239         print "PYTHONPATH=%s" % os.environ["PYTHONPATH"]
 240
 241 class RunWithPythonPath(Command):
 242     description = "Run a subcommand with PYTHONPATH set appropriately"
 243
 244     user_options = [ ("python", "p",
 245                       "Treat command string as arguments to a python executable"),
 246                      ("command=", "c", "Command to be run"),
 247                      ("directory=", "d", "Directory to run the command in"),
 248                      ]
 249     boolean_options = ["python"]
 250
 251     def initialize_options(self):
 252         self.command = None
 253         self.python = False
 254         self.directory = None
 255     def finalize_options(self):
 256         pass
 257     def run(self):
 258         # os.environ['PYTHONPATH'] is already set by add_tahoe_paths, so we
 259         # just need to exec() their command. We must require the command to
 260         # be safe to split on whitespace, and have --python and --directory
 261         # to make it easier to achieve this.
 262         command = []
 263         if self.python:
 264             command.append(sys.executable)
 265         if self.command:
 266             command.extend(self.command.split())
 267         if not command:
 268             raise RuntimeError("The --command argument is mandatory")
 269         if self.directory:
 270             os.chdir(self.directory)
 271         if self.verbose:
 272             print "command =", " ".join(command)
 273         rc = subprocess.call(command)
 274         sys.exit(rc)
 275
 276 class CheckAutoDeps(Command):
 277     user_options = []
 278     def initialize_options(self):
 279         pass
 280     def finalize_options(self):
 281         pass
 282     def run(self):
 283         import _auto_deps
 284         _auto_deps.require_auto_deps()
 285
 286
 287 class BuildTahoe(Command):
 288     user_options = []
 289     def initialize_options(self):
 290         pass
 291     def finalize_options(self):
 292         pass
 293     def run(self):
 294         # 'setup.py develop --prefix SUPPORT' will complain if SUPPORTLIB is
 295         # not on PYTHONPATH, because it thinks you are installing to a place
 296         # that will not be searched at runtime (which is true, except that we
 297         # add SUPPORTLIB to PYTHONPATH to run tests, etc). So set up
 298         # PYTHONPATH now, then spawn a 'setup.py develop' command. Also, we
 299         # have to create the directory ourselves.
 300         if not os.path.isdir(supportlib):
 301             os.makedirs(supportlib)
 302
 303         command = [sys.executable, "setup.py", "develop", "--prefix", "support"]
 304         if sys.platform == "linux2":
 305             # workaround for tahoe #229 / setuptools #17, on debian
 306             command.extend(["--site-dirs", "/var/lib/python-support/" + pyver])
 307         print "Command:", " ".join(command)
 308         rc = subprocess.call(command)
 309         if rc < 0:
 310             print >>sys.stderr, "'setup.py develop' terminated by signal", -rc
 311             sys.exit(1)
 312         elif rc > 0:
 313             print >>sys.stderr, "'setup.py develop' exited with rc", rc
 314             sys.exit(rc)
 315
 316 class Trial(Command):
 317     # Unlike 'build' and 'bdist_egg', the 'trial' subcommand cannot be run in
 318     # conjunction with other subcommands.
 319
 320     # The '-a' argument is split on whitespace and passed into trial. (the
 321     # distutils parser does not give subcommands access to the rest of
 322     # sys.argv, so unfortunately we cannot just do something like:
 323     #   setup.py trial --reporter=text allmydata.test.test_util
 324
 325     # Examples:
 326     #  setup.py trial    # run all tests
 327     #  setup.py trial -a allmydata.test.test_util   # run some tests
 328     #  setup.py trial -a '--reporter=text allmydata.test.test_util' #other args
 329
 330     description = "Run unit tests via trial"
 331
 332     user_options = [ ("args=", "a", "Argument string to pass to trial: setup.py trial -a allmydata.test.test_util"),
 333                      ]
 334     def initialize_options(self):
 335         self.args = "allmydata"
 336     def finalize_options(self):
 337         pass
 338
 339     def run(self):
 340         # make sure Twisted is available (for trial itself), and both the
 341         # Tahoe source code and our dependent libraries are available (so
 342         # that trial has some test code to work with)
 343
 344         from twisted.scripts import trial
 345
 346         args = self.args.strip().split()
 347
 348         # one wrinkle: we want to set the reactor here, because of bug #402
 349         # (twisted bug #3218). We just jam in a "--reactor poll" at the start
 350         # of the arglist. This does not permit the reactor to be overridden,
 351         # unfortunately.
 352         if sys.platform in ("linux2", "cygwin"):
 353             # poll on linux2 to avoid #402 problems with select
 354             # poll on cygwin since selectreactor runs out of fds
 355             args = ["--reactor", "poll"] + args
 356
 357         # zooko also had os.environ["PYTHONUNBUFFERED"]="1" and
 358         # args.append("--rterrors")
 359
 360         sys.argv = ["trial"] + args
 361         if self.verbose > 1:
 362             print "To run this test directly, use:"
 363             print "PYTHONPATH=%s %s" % (os.environ["PYTHONPATH"],
 364                                         " ".join(sys.argv))
 365         else:
 366             print "(run with -vv for trial command-line details)"
 367         trial.run() # this does sys.exit
 368         # NEVER REACHED
 369
 370 class MySdist(sdist.sdist):
 371     """ A hook in the sdist command so that we can determine whether this the
 372     tarball should be 'SUMO' or not, i.e. whether or not to include the
 373     external dependency tarballs.
 374     """
 375
 376     # Add our own sumo option to the sdist command, which toggles the
 377     # external dependencies being included in the sdist.
 378     user_options = sdist.sdist.user_options + \
 379         [('sumo', 's', "create a 'sumo' sdist which includes the external " \
 380           "dependencies")]
 381     boolean_options = ['sumo']
 382
 383     def initialize_options(self):
 384         sdist.sdist.initialize_options(self)
 385         self.sumo = None
 386
 387     def run(self):
 388         self.run_command('egg_info')
 389         ei_cmd = self.get_finalized_command('egg_info')
 390         self.filelist = ei_cmd.filelist
 391         self.filelist.append(os.path.join(ei_cmd.egg_info,'SOURCES.txt'))
 392
 393         # If '--sumo' wasn't specified in the arguments, do not include
 394         # the external dependency tarballs in the sdist.
 395         if not self.sumo:
 396             self.filelist.exclude_pattern(None, prefix='misc/dependencies')
 397
 398         print self.filelist.files
 399         self.check_readme()
 400         self.check_metadata()
 401         self.make_distribution()
 402
 403         dist_files = getattr(self.distribution,'dist_files',[])
 404         for file in self.archive_files:
 405             data = ('sdist', '', file)
 406             if data not in dist_files:
 407                 dist_files.append(data)
 408
 409 # get a list of the libraries that we depend upon, for use in the call to
 410 # setup() at the end of this file
 411 from _auto_deps import install_requires
 412
 413 setup(name='allmydata-tahoe',
 414       version=verstr,
 415       description='secure, decentralized, fault-tolerant filesystem',
 416       long_description=LONG_DESCRIPTION,
 417       author='the allmydata.org Tahoe project',
 418       author_email='tahoe-dev@allmydata.org',
 419       url='http://allmydata.org/',
 420       license='GNU GPL',
 421       cmdclass={"show_supportlib": ShowSupportLib,
 422                 "show_pythonpath": ShowPythonPath,
 423                 "run_with_pythonpath": RunWithPythonPath,
 424                 "check_auto_deps": CheckAutoDeps,
 425                 "build_tahoe": BuildTahoe,
 426                 "trial": Trial,
 427                 "sdist": MySdist,
 428                 },
 429       package_dir = {'':'src'},
 430       packages=find_packages("src"),
 431       classifiers=trove_classifiers,
 432       test_suite="allmydata.test",
 433       install_requires=install_requires,
 434       include_package_data=True,
 435       setup_requires=setup_requires,
 436       dependency_links=dependency_links,
 437       entry_points = { 'console_scripts': [ 'tahoe = allmydata.scripts.runner:run' ] },
 438       zip_safe=False, # We prefer unzipped for easier access.
 439       )